Client Management

/**
 * Base interface for gRPC-Web clients providing abstract methods for RPC operations
 */
abstract class AbstractClientBase {
  /**
   * Make an RPC call with callback-based response handling
   * @param method - The method URL to invoke
   * @param request - The request message instance
   * @param metadata - Request metadata headers
   * @param methodDescriptor - Method descriptor with type information
   * @param callback - Callback function for response/error handling
   * @returns ClientReadableStream for the call
   */
  abstract rpcCall<REQ, RESP>(
    method: string,
    request: REQ,
    metadata: Metadata,
    methodDescriptor: MethodDescriptor<REQ, RESP>,
    callback: (err: RpcError, response: RESP) => void
  ): ClientReadableStream<RESP>;

  /**
   * Make an RPC call with Promise-based response handling
   * @param method - The method URL to invoke
   * @param request - The request message instance
   * @param metadata - Request metadata headers
   * @param methodDescriptor - Method descriptor with type information
   * @param options - Options including abort signal for cancellation
   * @returns Promise resolving to the response message
   */
  abstract thenableCall<REQ, RESP>(
    method: string,
    request: REQ,
    metadata: Metadata,
    methodDescriptor: MethodDescriptor<REQ, RESP>,
    options?: PromiseCallOptions
  ): Promise<RESP>;

  /**
   * Create a server streaming call
   * @param method - The method URL to invoke
   * @param request - The request message instance
   * @param metadata - Request metadata headers
   * @param methodDescriptor - Method descriptor with type information
   * @returns ClientReadableStream for receiving streaming responses
   */
  abstract serverStreaming<REQ, RESP>(
    method: string,
    request: REQ,
    metadata: Metadata,
    methodDescriptor: MethodDescriptor<REQ, RESP>
  ): ClientReadableStream<RESP>;
}

/**
 * Concrete gRPC-Web client implementation with configurable options
 */
class GrpcWebClientBase extends AbstractClientBase {
  /**
   * Create a new gRPC-Web client
   * @param options - Configuration options for the client
   */
  constructor(options?: GrpcWebClientBaseOptions);

  /**
   * Make a unary RPC call with Promise-based response handling
   * This is an alias for thenableCall() for more semantic naming
   * @param method - The method URL to invoke
   * @param request - The request message instance
   * @param metadata - Request metadata headers
   * @param methodDescriptor - Method descriptor with type information
   * @param options - Options including abort signal for cancellation
   * @returns Promise resolving to the response message
   */
  unaryCall<REQ, RESP>(
    method: string,
    request: REQ,
    metadata: Metadata,
    methodDescriptor: MethodDescriptor<REQ, RESP>,
    options?: PromiseCallOptions
  ): Promise<RESP>;
}

/**
 * Configuration options for GrpcWebClientBase
 */
interface GrpcWebClientBaseOptions {
  /** Wire format: 'text' for base64-encoded or 'binary' for binary protobuf */
  format?: string;
  /** Suppress CORS preflight requests by encoding headers in URL parameters */
  suppressCorsPreflight?: boolean;
  /** Include credentials (cookies) in cross-origin requests */
  withCredentials?: boolean;
  /** Array of interceptors for unary RPC calls */
  unaryInterceptors?: UnaryInterceptor<unknown, unknown>[];
  /** Array of interceptors for streaming RPC calls */
  streamInterceptors?: StreamInterceptor<unknown, unknown>[];
}

/**
 * Options for Promise-based RPC calls
 */
interface PromiseCallOptions {
  /** AbortSignal to cancel the call */
  readonly signal?: AbortSignal;
}

import { GrpcWebClientBase } from "grpc-web";

// Basic client with default options
const client = new GrpcWebClientBase();

// Client with custom configuration
const client = new GrpcWebClientBase({
  format: 'binary',
  suppressCorsPreflight: true,
  withCredentials: true,
  unaryInterceptors: [authInterceptor, loggingInterceptor],
  streamInterceptors: [streamLoggingInterceptor]
});

// Making calls with different patterns
const response = await client.unaryCall(
  'https://api.example.com/service/Method',
  requestMessage,
  { 'custom-header': 'value' },
  methodDescriptor
);

// With cancellation support
const controller = new AbortController();
const responsePromise = client.unaryCall(
  'https://api.example.com/service/Method',
  requestMessage,
  {},
  methodDescriptor,
  { signal: controller.signal }
);

// Cancel the call after 5 seconds
setTimeout(() => controller.abort(), 5000);

try {
  const response = await responsePromise;
} catch (error) {
  if (error.code === StatusCode.CANCELLED) {
    console.log('Call was cancelled');
  }
}