@themainstack/communication 1.1.2 → 1.2.0

package/dist/grpc/server-factory.d.ts

@@ -1,5 +1,27 @@
 /**
- * Options for creating a gRPC server
+ * Base options for creating a gRPC server (without service-specific options)
+ */
+export interface ServerBaseOptions {
+    /** Port to listen on (default: 50051) */
+    port?: number;
+    /** Host to bind to (default: '0.0.0.0') */
+    host?: string;
+    /** Directory to save auto-generated proto files (default: './grpc') */
+    protoOutputDir?: string;
+}
+/**
+ * Service definition for adding a service to the server
+ */
+export interface ServiceDefinition {
+    /** The package name (e.g., 'fee.v1') */
+    packageName: string;
+    /** The service name (e.g., 'FeeService') */
+    serviceName: string;
+    /** Path to existing proto file (if not provided, will auto-generate) */
+    protoPath?: string;
+}
+/**
+ * Options for creating a gRPC server (single-service, backward compatible)
  */
 export interface GrpcServerOptions {
     /** The package name (e.g., 'fee.v1') */
@@ -28,34 +50,71 @@ export interface ServerMethodHandler<TReq = any, TRes = any> {
     /** Sample response for proto generation */
     responseSample: () => TRes;
 }
+/**
+ * Internal tracking of registered services
+ */
+interface RegisteredService {
+    packageName: string;
+    serviceName: string;
+    protoPath: string;
+}
 /**
  * GrpcServerFactory - Create and run gRPC servers easily
  *
- * Usage:
+ * Single-service usage (backward compatible):
  * ```typescript
  * const server = await GrpcServerFactory.createServer({
  *   packageName: 'fee.v1',
  *   serviceName: 'FeeService',
  *   port: 50053,
- * }, [
- *   {
- *     name: 'CalculateWithdrawalFee',
- *     handler: async (req) => calculateFee(req),
- *     requestSample: () => ({ merchantId: '', amount: 0 }),
- *     responseSample: () => ({ dollarAmount: 0, fees: [] }),
- *   }
- * ]);
+ * }, handlers);
+ *
+ * await server.start();
+ * ```
+ *
+ * Multi-service usage:
+ * ```typescript
+ * const server = GrpcServerFactory.create({ port: 50051 });
+ *
+ * await server.addService(
+ *   { packageName: 'fee.v1', serviceName: 'FeeService' },
+ *   feeHandlers
+ * );
+ * await server.addService(
+ *   { packageName: 'wallet.v1', serviceName: 'WalletService' },
+ *   walletHandlers
+ * );
  *
  * await server.start();
  * ```
  */
 export declare class GrpcServerFactory {
     private server;
-    private options;
+    private baseOptions;
+    private registeredServices;
     private isRunning;
+    private options;
     private constructor();
     /**
-     * Create a new gRPC server with the given handlers
+     * Create an empty gRPC server ready for adding multiple services
+     *
+     * Usage:
+     * ```typescript
+     * const server = GrpcServerFactory.create({ port: 50051 });
+     * await server.addService({ packageName: 'fee.v1', serviceName: 'FeeService' }, handlers);
+     * await server.start();
+     * ```
+     */
+    static create(options?: ServerBaseOptions): GrpcServerFactory;
+    /**
+     * Add a service to this server
+     *
+     * @param service - Service definition (package name, service name, optional proto path)
+     * @param handlers - Method handlers for this service
+     */
+    addService(service: ServiceDefinition, handlers: ServerMethodHandler[]): Promise<void>;
+    /**
+     * Create a new gRPC server with the given handlers (single-service, backward compatible)
      */
     static createServer(options: GrpcServerOptions, handlers: ServerMethodHandler[]): Promise<GrpcServerFactory>;
     /**
@@ -78,6 +137,10 @@ export declare class GrpcServerFactory {
      * Get the server address
      */
     get address(): string;
+    /**
+     * Get list of registered services
+     */
+    get services(): ReadonlyArray<RegisteredService>;
 }
 /**
  * Helper function to quickly expose a function as a gRPC service
@@ -96,3 +159,4 @@ export declare function exposeAsGrpc<TReq extends object, TRes extends object>(m
     requestSample: () => TReq;
     responseSample: () => TRes;
 }, options: GrpcServerOptions): Promise<GrpcServerFactory>;
+export {};

package/dist/grpc/server-factory.js

@@ -43,43 +43,74 @@ const struct_utils_1 = require("./struct-utils");
 /**
  * GrpcServerFactory - Create and run gRPC servers easily
  *
- * Usage:
+ * Single-service usage (backward compatible):
  * ```typescript
  * const server = await GrpcServerFactory.createServer({
  *   packageName: 'fee.v1',
  *   serviceName: 'FeeService',
  *   port: 50053,
- * }, [
- *   {
- *     name: 'CalculateWithdrawalFee',
- *     handler: async (req) => calculateFee(req),
- *     requestSample: () => ({ merchantId: '', amount: 0 }),
- *     responseSample: () => ({ dollarAmount: 0, fees: [] }),
- *   }
- * ]);
+ * }, handlers);
+ *
+ * await server.start();
+ * ```
+ *
+ * Multi-service usage:
+ * ```typescript
+ * const server = GrpcServerFactory.create({ port: 50051 });
+ *
+ * await server.addService(
+ *   { packageName: 'fee.v1', serviceName: 'FeeService' },
+ *   feeHandlers
+ * );
+ * await server.addService(
+ *   { packageName: 'wallet.v1', serviceName: 'WalletService' },
+ *   walletHandlers
+ * );
  *
  * await server.start();
  * ```
  */
 class GrpcServerFactory {
-    constructor(server, options) {
+    constructor(server, baseOptions) {
+        this.registeredServices = [];
         this.isRunning = false;
+        // For backward compatibility with single-service usage
+        this.options = null;
         this.server = server;
-        this.options = options;
+        this.baseOptions = baseOptions;
     }
     /**
-     * Create a new gRPC server with the given handlers
+     * Create an empty gRPC server ready for adding multiple services
+     *
+     * Usage:
+     * ```typescript
+     * const server = GrpcServerFactory.create({ port: 50051 });
+     * await server.addService({ packageName: 'fee.v1', serviceName: 'FeeService' }, handlers);
+     * await server.start();
+     * ```
      */
-    static async createServer(options, handlers) {
+    static create(options = {}) {
         const fullOptions = {
             port: 50051,
             host: '0.0.0.0',
             protoOutputDir: './grpc',
-            protoPath: '',
             ...options,
         };
+        const server = new grpc.Server();
+        return new GrpcServerFactory(server, fullOptions);
+    }
+    /**
+     * Add a service to this server
+     *
+     * @param service - Service definition (package name, service name, optional proto path)
+     * @param handlers - Method handlers for this service
+     */
+    async addService(service, handlers) {
+        if (this.isRunning) {
+            throw new Error('Cannot add services to a running server. Call addService() before start().');
+        }
         // Step 1: Generate or load proto file
-        let protoPath = fullOptions.protoPath;
+        let protoPath = service.protoPath;
         if (!protoPath) {
             // Auto-generate proto from handlers
             const methodDefinitions = handlers.map(h => ({
@@ -88,16 +119,16 @@ class GrpcServerFactory {
                 responseSample: h.responseSample,
             }));
             const protoContent = (0, proto_generator_1.generateProtoFromMethods)(methodDefinitions, {
-                packageName: fullOptions.packageName,
-                serviceName: fullOptions.serviceName,
-                outputDir: fullOptions.protoOutputDir,
+                packageName: service.packageName,
+                serviceName: service.serviceName,
+                outputDir: this.baseOptions.protoOutputDir,
             });
-            protoPath = path.join(fullOptions.protoOutputDir, `${fullOptions.serviceName.toLowerCase().replace(/service$/, '')}.proto`);
+            protoPath = path.join(this.baseOptions.protoOutputDir, `${service.serviceName.toLowerCase().replace(/service$/, '')}.proto`);
             console.log(`Proto file auto-generated: ${protoPath}`);
         }
         // Step 2: Load the proto definition
         const packageDefinition = protoLoader.loadSync(protoPath, {
-            keepCase: false, // Convert snake_case to camelCase
+            keepCase: false,
             longs: String,
             enums: String,
             defaults: true,
@@ -106,21 +137,20 @@ class GrpcServerFactory {
         const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
         // Step 3: Navigate to the service definition
         let serviceDefinition = protoDescriptor;
-        const packageParts = fullOptions.packageName.split('.');
+        const packageParts = service.packageName.split('.');
         for (const part of packageParts) {
             serviceDefinition = serviceDefinition[part];
             if (!serviceDefinition) {
-                throw new Error(`Package '${fullOptions.packageName}' not found in proto`);
+                throw new Error(`Package '${service.packageName}' not found in proto`);
             }
         }
-        const ServiceConstructor = serviceDefinition[fullOptions.serviceName];
+        const ServiceConstructor = serviceDefinition[service.serviceName];
         if (!ServiceConstructor || !ServiceConstructor.service) {
-            throw new Error(`Service '${fullOptions.serviceName}' not found in package '${fullOptions.packageName}'`);
+            throw new Error(`Service '${service.serviceName}' not found in package '${service.packageName}'`);
         }
         // Step 4: Create handler implementations
         const implementations = {};
         for (const handler of handlers) {
-            // gRPC uses lowercase first letter for method names in implementation
             const methodName = handler.name.charAt(0).toLowerCase() + handler.name.slice(1);
             implementations[methodName] = async (call, callback) => {
                 try {
@@ -130,7 +160,6 @@ class GrpcServerFactory {
                     if (methodDef && methodDef.requestType && methodDef.requestType.format === 'Protocol Buffer 3 DescriptorProto') {
                         for (const field of methodDef.requestType.type.field) {
                             if (field.typeName === 'google.protobuf.Struct' && request[field.name]) {
-                                // Convert Struct -> JSON for the handler
                                 request[field.name] = (0, struct_utils_1.structToJson)(request[field.name]);
                             }
                         }
@@ -140,7 +169,6 @@ class GrpcServerFactory {
                     if (result && typeof result === 'object' && methodDef && methodDef.responseType && methodDef.responseType.format === 'Protocol Buffer 3 DescriptorProto') {
                         for (const field of methodDef.responseType.type.field) {
                             if (field.typeName === 'google.protobuf.Struct' && result[field.name]) {
-                                // Convert JSON -> Struct for the callback
                                 result[field.name] = (0, struct_utils_1.jsonToStruct)(result[field.name]);
                             }
                         }
@@ -156,17 +184,53 @@ class GrpcServerFactory {
                 }
             };
         }
-        // Step 5: Create and configure the server
-        const server = new grpc.Server();
-        server.addService(ServiceConstructor.service, implementations);
-        return new GrpcServerFactory(server, { ...fullOptions, protoPath });
+        // Step 5: Add service to server
+        this.server.addService(ServiceConstructor.service, implementations);
+        // Track the registered service
+        this.registeredServices.push({
+            packageName: service.packageName,
+            serviceName: service.serviceName,
+            protoPath,
+        });
+    }
+    /**
+     * Create a new gRPC server with the given handlers (single-service, backward compatible)
+     */
+    static async createServer(options, handlers) {
+        // Only pass defined values to avoid overriding defaults with undefined
+        const baseOptions = {};
+        if (options.port !== undefined)
+            baseOptions.port = options.port;
+        if (options.host !== undefined)
+            baseOptions.host = options.host;
+        if (options.protoOutputDir !== undefined)
+            baseOptions.protoOutputDir = options.protoOutputDir;
+        const factory = GrpcServerFactory.create(baseOptions);
+        await factory.addService({
+            packageName: options.packageName,
+            serviceName: options.serviceName,
+            protoPath: options.protoPath,
+        }, handlers);
+        // Store full options for backward compatibility (used in start() logging)
+        factory.options = {
+            port: factory.baseOptions.port,
+            host: factory.baseOptions.host,
+            protoOutputDir: factory.baseOptions.protoOutputDir,
+            protoPath: options.protoPath || '',
+            packageName: options.packageName,
+            serviceName: options.serviceName,
+        };
+        return factory;
     }
     /**
      * Start the gRPC server
      */
     async start() {
+        if (this.registeredServices.length === 0) {
+            throw new Error('No services registered. Call addService() before start().');
+        }
         return new Promise((resolve, reject) => {
-            const address = `${this.options.host}:${this.options.port}`;
+            const address = `${this.baseOptions.host}:${this.baseOptions.port}`;
             this.server.bindAsync(address, grpc.ServerCredentials.createInsecure(), (error, port) => {
                 if (error) {
                     reject(error);
@@ -174,8 +238,11 @@ class GrpcServerFactory {
                 }
                 this.isRunning = true;
                 console.log(` gRPC Server running on ${address}`);
-                console.log(`   Service: ${this.options.serviceName}`);
-                console.log(`   Package: ${this.options.packageName}`);
+                // Log all registered services
+                for (const svc of this.registeredServices) {
+                    console.log(`   Service: ${svc.serviceName}`);
+                    console.log(`   Package: ${svc.packageName}`);
+                }
                 resolve();
             });
         });
@@ -210,7 +277,13 @@ class GrpcServerFactory {
      * Get the server address
      */
     get address() {
-        return `${this.options.host}:${this.options.port}`;
+        return `${this.baseOptions.host}:${this.baseOptions.port}`;
+    }
+    /**
+     * Get list of registered services
+     */
+    get services() {
+        return this.registeredServices;
     }
 }
 exports.GrpcServerFactory = GrpcServerFactory;

package/grpc/test.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package test.v1;
+
+// TestService - Auto-generated gRPC service
+service TestService {
+  rpc Ping (PingRequest) returns (PingResponse) {}
+}
+
+message PingResponse {
+  bool pong = 1;
+}
+
+message PingRequest {
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@themainstack/communication",
-    "version": "1.1.2",
+    "version": "1.2.0",
     "private": false,
     "description": "Unified gRPC framework for inter-service communication - auto-generates protos, creates servers, and provides type-safe clients",
     "main": "dist/index.js",

package/src/grpc/server-factory.ts

@@ -6,7 +6,31 @@ import { generateProtoFromMethods, MethodDefinition } from '../proto-generator';
 import { jsonToStruct, structToJson } from './struct-utils';
 
 /**
- * Options for creating a gRPC server
+ * Base options for creating a gRPC server (without service-specific options)
+ */
+export interface ServerBaseOptions {
+    /** Port to listen on (default: 50051) */
+    port?: number;
+    /** Host to bind to (default: '0.0.0.0') */
+    host?: string;
+    /** Directory to save auto-generated proto files (default: './grpc') */
+    protoOutputDir?: string;
+}
+
+/**
+ * Service definition for adding a service to the server
+ */
+export interface ServiceDefinition {
+    /** The package name (e.g., 'fee.v1') */
+    packageName: string;
+    /** The service name (e.g., 'FeeService') */
+    serviceName: string;
+    /** Path to existing proto file (if not provided, will auto-generate) */
+    protoPath?: string;
+}
+
+/**
+ * Options for creating a gRPC server (single-service, backward compatible)
  */
 export interface GrpcServerOptions {
     /** The package name (e.g., 'fee.v1') */
@@ -37,57 +61,100 @@ export interface ServerMethodHandler<TReq = any, TRes = any> {
     responseSample: () => TRes;
 }
 
+/**
+ * Internal tracking of registered services
+ */
+interface RegisteredService {
+    packageName: string;
+    serviceName: string;
+    protoPath: string;
+}
+
 /**
  * GrpcServerFactory - Create and run gRPC servers easily
  * 
- * Usage:
+ * Single-service usage (backward compatible):
  * ```typescript
  * const server = await GrpcServerFactory.createServer({
  *   packageName: 'fee.v1',
  *   serviceName: 'FeeService',
  *   port: 50053,
- * }, [
- *   {
- *     name: 'CalculateWithdrawalFee',
- *     handler: async (req) => calculateFee(req),
- *     requestSample: () => ({ merchantId: '', amount: 0 }),
- *     responseSample: () => ({ dollarAmount: 0, fees: [] }),
- *   }
- * ]);
+ * }, handlers);
+ * 
+ * await server.start();
+ * ```
+ * 
+ * Multi-service usage:
+ * ```typescript
+ * const server = GrpcServerFactory.create({ port: 50051 });
+ * 
+ * await server.addService(
+ *   { packageName: 'fee.v1', serviceName: 'FeeService' },
+ *   feeHandlers
+ * );
+ * await server.addService(
+ *   { packageName: 'wallet.v1', serviceName: 'WalletService' },
+ *   walletHandlers
+ * );
  * 
  * await server.start();
  * ```
  */
 export class GrpcServerFactory {
     private server: grpc.Server;
-    private options: Required<GrpcServerOptions>;
+    private baseOptions: Required<ServerBaseOptions>;
+    private registeredServices: RegisteredService[] = [];
     private isRunning: boolean = false;
 
+    // For backward compatibility with single-service usage
+    private options: Required<GrpcServerOptions> | null = null;
+
     private constructor(
         server: grpc.Server,
-        options: Required<GrpcServerOptions>
+        baseOptions: Required<ServerBaseOptions>
     ) {
         this.server = server;
-        this.options = options;
+        this.baseOptions = baseOptions;
     }
 
     /**
-     * Create a new gRPC server with the given handlers
+     * Create an empty gRPC server ready for adding multiple services
+     * 
+     * Usage:
+     * ```typescript
+     * const server = GrpcServerFactory.create({ port: 50051 });
+     * await server.addService({ packageName: 'fee.v1', serviceName: 'FeeService' }, handlers);
+     * await server.start();
+     * ```
      */
-    static async createServer(
-        options: GrpcServerOptions,
-        handlers: ServerMethodHandler[]
-    ): Promise<GrpcServerFactory> {
-        const fullOptions: Required<GrpcServerOptions> = {
+    static create(options: ServerBaseOptions = {}): GrpcServerFactory {
+        const fullOptions: Required<ServerBaseOptions> = {
             port: 50051,
             host: '0.0.0.0',
             protoOutputDir: './grpc',
-            protoPath: '',
             ...options,
         };
 
+        const server = new grpc.Server();
+        return new GrpcServerFactory(server, fullOptions);
+    }
+
+    /**
+     * Add a service to this server
+     * 
+     * @param service - Service definition (package name, service name, optional proto path)
+     * @param handlers - Method handlers for this service
+     */
+    async addService(
+        service: ServiceDefinition,
+        handlers: ServerMethodHandler[]
+    ): Promise<void> {
+        if (this.isRunning) {
+            throw new Error('Cannot add services to a running server. Call addService() before start().');
+        }
+
         // Step 1: Generate or load proto file
-        let protoPath = fullOptions.protoPath;
+        let protoPath = service.protoPath;
 
         if (!protoPath) {
             // Auto-generate proto from handlers
@@ -98,14 +165,14 @@ export class GrpcServerFactory {
             }));
 
             const protoContent = generateProtoFromMethods(methodDefinitions, {
-                packageName: fullOptions.packageName,
-                serviceName: fullOptions.serviceName,
-                outputDir: fullOptions.protoOutputDir,
+                packageName: service.packageName,
+                serviceName: service.serviceName,
+                outputDir: this.baseOptions.protoOutputDir,
             });
 
             protoPath = path.join(
-                fullOptions.protoOutputDir,
-                `${fullOptions.serviceName.toLowerCase().replace(/service$/, '')}.proto`
+                this.baseOptions.protoOutputDir,
+                `${service.serviceName.toLowerCase().replace(/service$/, '')}.proto`
             );
 
             console.log(`Proto file auto-generated: ${protoPath}`);
@@ -113,7 +180,7 @@ export class GrpcServerFactory {
 
         // Step 2: Load the proto definition
         const packageDefinition = protoLoader.loadSync(protoPath, {
-            keepCase: false, // Convert snake_case to camelCase
+            keepCase: false,
             longs: String,
             enums: String,
             defaults: true,
@@ -124,24 +191,23 @@ export class GrpcServerFactory {
 
         // Step 3: Navigate to the service definition
         let serviceDefinition: any = protoDescriptor;
-        const packageParts = fullOptions.packageName.split('.');
+        const packageParts = service.packageName.split('.');
         for (const part of packageParts) {
             serviceDefinition = serviceDefinition[part];
             if (!serviceDefinition) {
-                throw new Error(`Package '${fullOptions.packageName}' not found in proto`);
+                throw new Error(`Package '${service.packageName}' not found in proto`);
             }
         }
 
-        const ServiceConstructor = serviceDefinition[fullOptions.serviceName];
+        const ServiceConstructor = serviceDefinition[service.serviceName];
         if (!ServiceConstructor || !ServiceConstructor.service) {
-            throw new Error(`Service '${fullOptions.serviceName}' not found in package '${fullOptions.packageName}'`);
+            throw new Error(`Service '${service.serviceName}' not found in package '${service.packageName}'`);
         }
 
         // Step 4: Create handler implementations
         const implementations: Record<string, grpc.handleUnaryCall<any, any>> = {};
 
         for (const handler of handlers) {
-            // gRPC uses lowercase first letter for method names in implementation
             const methodName = handler.name.charAt(0).toLowerCase() + handler.name.slice(1);
 
             implementations[methodName] = async (
@@ -156,7 +222,6 @@ export class GrpcServerFactory {
                     if (methodDef && methodDef.requestType && methodDef.requestType.format === 'Protocol Buffer 3 DescriptorProto') {
                         for (const field of methodDef.requestType.type.field) {
                             if (field.typeName === 'google.protobuf.Struct' && request[field.name]) {
-                                // Convert Struct -> JSON for the handler
                                 request[field.name] = structToJson(request[field.name]);
                             }
                         }
@@ -168,7 +233,6 @@ export class GrpcServerFactory {
                     if (result && typeof result === 'object' && methodDef && methodDef.responseType && methodDef.responseType.format === 'Protocol Buffer 3 DescriptorProto') {
                         for (const field of methodDef.responseType.type.field) {
                             if (field.typeName === 'google.protobuf.Struct' && result[field.name]) {
-                                // Convert JSON -> Struct for the callback
                                 result[field.name] = jsonToStruct(result[field.name]);
                             }
                         }
@@ -185,19 +249,61 @@ export class GrpcServerFactory {
             };
         }
 
-        // Step 5: Create and configure the server
-        const server = new grpc.Server();
-        server.addService(ServiceConstructor.service, implementations);
+        // Step 5: Add service to server
+        this.server.addService(ServiceConstructor.service, implementations);
+
+        // Track the registered service
+        this.registeredServices.push({
+            packageName: service.packageName,
+            serviceName: service.serviceName,
+            protoPath,
+        });
+    }
 
-        return new GrpcServerFactory(server, { ...fullOptions, protoPath });
+    /**
+     * Create a new gRPC server with the given handlers (single-service, backward compatible)
+     */
+    static async createServer(
+        options: GrpcServerOptions,
+        handlers: ServerMethodHandler[]
+    ): Promise<GrpcServerFactory> {
+        // Only pass defined values to avoid overriding defaults with undefined
+        const baseOptions: ServerBaseOptions = {};
+        if (options.port !== undefined) baseOptions.port = options.port;
+        if (options.host !== undefined) baseOptions.host = options.host;
+        if (options.protoOutputDir !== undefined) baseOptions.protoOutputDir = options.protoOutputDir;
+
+        const factory = GrpcServerFactory.create(baseOptions);
+
+        await factory.addService({
+            packageName: options.packageName,
+            serviceName: options.serviceName,
+            protoPath: options.protoPath,
+        }, handlers);
+
+        // Store full options for backward compatibility (used in start() logging)
+        factory.options = {
+            port: factory.baseOptions.port,
+            host: factory.baseOptions.host,
+            protoOutputDir: factory.baseOptions.protoOutputDir,
+            protoPath: options.protoPath || '',
+            packageName: options.packageName,
+            serviceName: options.serviceName,
+        };
+
+        return factory;
     }
 
     /**
      * Start the gRPC server
      */
     async start(): Promise<void> {
+        if (this.registeredServices.length === 0) {
+            throw new Error('No services registered. Call addService() before start().');
+        }
+
         return new Promise((resolve, reject) => {
-            const address = `${this.options.host}:${this.options.port}`;
+            const address = `${this.baseOptions.host}:${this.baseOptions.port}`;
 
             this.server.bindAsync(
                 address,
@@ -210,8 +316,13 @@ export class GrpcServerFactory {
 
                     this.isRunning = true;
                     console.log(` gRPC Server running on ${address}`);
-                    console.log(`   Service: ${this.options.serviceName}`);
-                    console.log(`   Package: ${this.options.packageName}`);
+
+                    // Log all registered services
+                    for (const svc of this.registeredServices) {
+                        console.log(`   Service: ${svc.serviceName}`);
+                        console.log(`   Package: ${svc.packageName}`);
+                    }
+
                     resolve();
                 }
             );
@@ -251,7 +362,14 @@ export class GrpcServerFactory {
      * Get the server address
      */
     get address(): string {
-        return `${this.options.host}:${this.options.port}`;
+        return `${this.baseOptions.host}:${this.baseOptions.port}`;
+    }
+
+    /**
+     * Get list of registered services
+     */
+    get services(): ReadonlyArray<RegisteredService> {
+        return this.registeredServices;
     }
 }
 

package/tests/fixtures/calculator.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package calc.v1;
+
+// CalculatorService - Auto-generated gRPC service
+service CalculatorService {
+  rpc Add (AddRequest) returns (AddResponse) {}
+}
+
+message AddResponse {
+  int32 result = 1;
+}
+
+message AddRequest {
+  int32 a = 1;
+  int32 b = 2;
+}

package/tests/fixtures/echo.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+package echo.v1;
+
+// EchoService - Auto-generated gRPC service
+service EchoService {
+  rpc Echo (EchoRequest) returns (EchoResponse) {}
+}
+
+message EchoResponse {
+  string reply = 1;
+}
+
+message EchoRequest {
+  string message = 1;
+}

package/tests/multi-service.spec.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { GrpcServerFactory, GrpcClientFactory } from '../src/index';
+import * as path from 'path';
+import * as fs from 'fs';
+
+describe('Multi-Service Support', () => {
+    it('should support multiple services on one server', async () => {
+        const PORT = 50059;
+        const FIXTURES_DIR = path.join(__dirname, 'fixtures');
+
+        if (!fs.existsSync(FIXTURES_DIR)) {
+            fs.mkdirSync(FIXTURES_DIR, { recursive: true });
+        }
+
+        // Create empty server
+        const server = GrpcServerFactory.create({
+            port: PORT,
+            protoOutputDir: FIXTURES_DIR,
+        });
+
+        // Add first service: Calculator
+        await server.addService(
+            { packageName: 'calc.v1', serviceName: 'CalculatorService' },
+            [{
+                name: 'Add',
+                handler: async (req: { a: number; b: number }) => ({ result: req.a + req.b }),
+                requestSample: () => ({ a: 0, b: 0 }),
+                responseSample: () => ({ result: 0 }),
+            }]
+        );
+
+        // Add second service: Echo  
+        await server.addService(
+            { packageName: 'echo.v1', serviceName: 'EchoService' },
+            [{
+                name: 'Echo',
+                handler: async (req: { message: string }) => ({ reply: `Echo: ${req.message}` }),
+                requestSample: () => ({ message: '' }),
+                responseSample: () => ({ reply: '' }),
+            }]
+        );
+
+        // Verify services are registered
+        expect(server.services).toHaveLength(2);
+        expect(server.services[0].serviceName).toBe('CalculatorService');
+        expect(server.services[1].serviceName).toBe('EchoService');
+
+        // Start server
+        await server.start();
+
+        try {
+            // Create client for Calculator
+            const calcClient = GrpcClientFactory.createClient<any>({
+                packageName: 'calc.v1',
+                serviceName: 'CalculatorService',
+                protoPath: path.join(FIXTURES_DIR, 'calculator.proto'),
+                url: `0.0.0.0:${PORT}`,
+            });
+
+            // Create client for Echo
+            const echoClient = GrpcClientFactory.createClient<any>({
+                packageName: 'echo.v1',
+                serviceName: 'EchoService',
+                protoPath: path.join(FIXTURES_DIR, 'echo.proto'),
+                url: `0.0.0.0:${PORT}`,
+            });
+
+            // Test Calculator service
+            const calcResult = await new Promise((resolve, reject) => {
+                calcClient.Add({ a: 5, b: 3 }, (err: any, res: any) => {
+                    if (err) reject(err);
+                    else resolve(res);
+                });
+            });
+            expect((calcResult as any).result).toBe(8);
+
+            // Test Echo service
+            const echoResult = await new Promise((resolve, reject) => {
+                echoClient.Echo({ message: 'hello' }, (err: any, res: any) => {
+                    if (err) reject(err);
+                    else resolve(res);
+                });
+            });
+            expect((echoResult as any).reply).toBe('Echo: hello');
+
+        } finally {
+            server.stop();
+        }
+    });
+
+    it('should throw if addService is called after start', async () => {
+        const server = GrpcServerFactory.create({ port: 50060 });
+
+        await server.addService(
+            { packageName: 'test.v1', serviceName: 'TestService' },
+            [{
+                name: 'Ping',
+                handler: async () => ({ pong: true }),
+                requestSample: () => ({}),
+                responseSample: () => ({ pong: true }),
+            }]
+        );
+
+        await server.start();
+
+        await expect(
+            server.addService(
+                { packageName: 'test2.v1', serviceName: 'Test2Service' },
+                [{ name: 'Ping', handler: async () => ({}), requestSample: () => ({}), responseSample: () => ({}) }]
+            )
+        ).rejects.toThrow('Cannot add services to a running server');
+
+        server.stop();
+    });
+
+    it('should throw if start is called without services', async () => {
+        const server = GrpcServerFactory.create({ port: 50061 });
+
+        await expect(server.start()).rejects.toThrow('No services registered');
+    });
+});