@naman_deep_singh/communication-core 1.0.0

package/dist/types/types/events.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Event types for communication layer
+ * @packageDocumentation
+ */
+import type { ServiceInstance } from './service.js';
+import type { CircuitBreakerState } from './config.js';
+import type { CommunicationError } from '../errors/CommunicationError.js';
+/**
+ * Base event interface
+ */
+export interface BaseEvent {
+    /** Event type */
+    type: string;
+    /** Event timestamp */
+    timestamp: number;
+    /** Event source */
+    source?: string;
+    /** Correlation ID for tracing */
+    correlationId?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Circuit breaker events
+ */
+export interface CircuitBreakerEvent extends BaseEvent {
+    type: 'circuit-breaker';
+    /** Circuit breaker name */
+    name: string;
+    /** New state */
+    state: CircuitBreakerState;
+    /** Previous state */
+    previousState: CircuitBreakerState;
+    /** Failure count */
+    failureCount: number;
+    /** Success count */
+    successCount: number;
+    /** Error that triggered state change */
+    error?: CommunicationError;
+}
+/**
+ * Retry events
+ */
+export interface RetryEvent extends BaseEvent {
+    type: 'retry';
+    /** Operation being retried */
+    operation: string;
+    /** Current retry attempt */
+    attempt: number;
+    /** Maximum retry attempts */
+    maxAttempts: number;
+    /** Delay before next retry in milliseconds */
+    delay: number;
+    /** Error that triggered retry */
+    error: CommunicationError;
+    /** Total elapsed time in milliseconds */
+    elapsedTime: number;
+}
+/**
+ * Service discovery events
+ */
+export interface ServiceDiscoveryEvent extends BaseEvent {
+    type: 'service-discovery';
+    /** Service name */
+    serviceName: string;
+    /** Event subtype */
+    subtype: 'registered' | 'deregistered' | 'updated' | 'health-changed';
+    /** Service instance */
+    instance: ServiceInstance;
+    /** Previous instance state (for updates) */
+    previousInstance?: ServiceInstance;
+    /** List of all available instances after event */
+    allInstances: ServiceInstance[];
+}
+/**
+ * Load balancing events
+ */
+export interface LoadBalancingEvent extends BaseEvent {
+    type: 'load-balancing';
+    /** Service name */
+    serviceName: string;
+    /** Selected instance */
+    selectedInstance: ServiceInstance;
+    /** Available instances */
+    availableInstances: ServiceInstance[];
+    /** Load balancing strategy used */
+    strategy: string;
+    /** Selection duration in milliseconds */
+    selectionDuration: number;
+}
+/**
+ * Protocol events
+ */
+export interface ProtocolEvent extends BaseEvent {
+    type: 'protocol';
+    /** Protocol name */
+    protocol: string;
+    /** Event subtype */
+    subtype: 'request' | 'response' | 'error' | 'connection' | 'disconnection';
+    /** Request ID */
+    requestId?: string;
+    /** Duration in milliseconds (for request/response) */
+    duration?: number;
+    /** Status code (for HTTP responses) */
+    statusCode?: number;
+    /** Error (for error events) */
+    error?: CommunicationError;
+    /** Payload size in bytes */
+    payloadSize?: number;
+}
+/**
+ * Connection events
+ */
+export interface ConnectionEvent extends BaseEvent {
+    type: 'connection';
+    /** Event subtype */
+    subtype: 'opened' | 'closed' | 'error' | 'reconnected';
+    /** Connection ID */
+    connectionId: string;
+    /** Remote address */
+    remoteAddress?: string;
+    /** Connection duration in milliseconds */
+    duration?: number;
+    /** Error (for error events) */
+    error?: CommunicationError;
+    /** Reconnection attempt number */
+    reconnectionAttempt?: number;
+}
+/**
+ * Metrics events
+ */
+export interface MetricsEvent extends BaseEvent {
+    type: 'metrics';
+    /** Metrics name */
+    name: string;
+    /** Metrics value */
+    value: number;
+    /** Metrics type */
+    metricsType: 'counter' | 'gauge' | 'histogram' | 'summary';
+    /** Labels/tags */
+    labels?: Record<string, string>;
+    /** Timestamp when metrics was collected */
+    collectedAt: number;
+}
+/**
+ * Cache events
+ */
+export interface CacheEvent extends BaseEvent {
+    type: 'cache';
+    /** Event subtype */
+    subtype: 'hit' | 'miss' | 'set' | 'delete' | 'expire' | 'clear';
+    /** Cache key */
+    key: string;
+    /** Cache value size in bytes */
+    valueSize?: number;
+    /** Cache TTL in milliseconds */
+    ttl?: number;
+    /** Cache hit/miss ratio */
+    hitRatio?: number;
+}
+/**
+ * Interceptor events
+ */
+export interface InterceptorEvent extends BaseEvent {
+    type: 'interceptor';
+    /** Interceptor name */
+    interceptor: string;
+    /** Event subtype */
+    subtype: 'before' | 'after' | 'error';
+    /** Request ID */
+    requestId: string;
+    /** Duration in milliseconds (for after events) */
+    duration?: number;
+    /** Error (for error events) */
+    error?: CommunicationError;
+    /** Modified request/response */
+    modification?: {
+        type: 'request' | 'response';
+        changes: string[];
+    };
+}
+/**
+ * Union type of all events
+ */
+export type CommunicationEvent = CircuitBreakerEvent | RetryEvent | ServiceDiscoveryEvent | LoadBalancingEvent | ProtocolEvent | ConnectionEvent | MetricsEvent | CacheEvent | InterceptorEvent;
+/**
+ * Event listener callback
+ */
+export type EventListener = (event: CommunicationEvent) => void | Promise<void>;
+/**
+ * Event emitter interface
+ */
+export interface EventEmitter {
+    /** Subscribe to events */
+    on(eventType: string | string[], listener: EventListener): void;
+    /** Subscribe to events once */
+    once(eventType: string | string[], listener: EventListener): void;
+    /** Unsubscribe from events */
+    off(eventType: string | string[], listener: EventListener): void;
+    /** Emit an event */
+    emit(event: CommunicationEvent): void;
+    /** Remove all listeners */
+    removeAllListeners(eventType?: string): void;
+}

package/dist/types/types/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Type definitions for communication layer
+ * @packageDocumentation
+ */
+export type { HttpMethod, ProtocolType, ServiceDiscoveryType, LoadBalanceStrategy, CircuitBreakerState, BackoffStrategy, SerializationFormat, LogLevel, ClientConfig, ServiceDiscoveryConfig, LoadBalancingConfig, ResilienceConfig, CircuitBreakerConfig, RetryPolicyConfig, TimeoutConfig, BulkheadConfig, FallbackConfig, ConnectionPoolConfig, CompressionConfig, RateLimitConfig, BaseProtocolConfig, HttpProtocolConfig, GrpcProtocolConfig, WebSocketProtocolConfig, InterceptorConfig, SerializationConfig, LoggingConfig, MetricsConfig, CacheConfig, } from './config.js';
+export type { BaseRequest, HttpRequest, GrpcRequest, WebSocketRequest, RetryConfig, CircuitBreakerRequestConfig, Request, RequestOptions, RequestContext, } from './request.js';
+export type { BaseResponse, HttpResponse, GrpcResponse, WebSocketResponse, ErrorResponse, PaginatedResponse, StreamResponse, Response, } from './response.js';
+export type { ServiceInstance, ServiceRegistration, WatchCallback, UnwatchFunction, HealthCheckResult, ServiceEndpoint, ServiceDependency, ServiceMetrics, ServiceRegistryConfig, ServiceInstanceFilter, ServiceDiscoveryResult, } from './service.js';
+export type { BaseEvent, CircuitBreakerEvent, RetryEvent, ServiceDiscoveryEvent, LoadBalancingEvent, ProtocolEvent, ConnectionEvent, MetricsEvent, CacheEvent, InterceptorEvent, CommunicationEvent, EventListener, EventEmitter, } from './events.js';

package/dist/types/types/request.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Request types and interfaces for communication layer
+ * @packageDocumentation
+ */
+import type { HttpMethod } from './config.js';
+/**
+ * Base request interface for all protocols
+ */
+export interface BaseRequest {
+    /** Unique request identifier */
+    id?: string;
+    /** Request timestamp */
+    timestamp?: number;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request metadata */
+    metadata?: Record<string, unknown>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Retry configuration for this specific request */
+    retry?: RetryConfig;
+    /** Circuit breaker configuration for this request */
+    circuitBreaker?: CircuitBreakerRequestConfig;
+}
+/**
+ * HTTP-specific request
+ */
+export interface HttpRequest extends BaseRequest {
+    /** HTTP method */
+    method: HttpMethod;
+    /** Request URL */
+    url: string;
+    /** Request body */
+    body?: unknown;
+    /** Query parameters */
+    query?: Record<string, string | number | boolean>;
+    /** Path parameters */
+    params?: Record<string, string>;
+    /** Response type */
+    responseType?: 'json' | 'text' | 'arraybuffer' | 'stream';
+}
+/**
+ * gRPC-specific request
+ */
+export interface GrpcRequest extends BaseRequest {
+    /** gRPC service name */
+    service: string;
+    /** gRPC method name */
+    method: string;
+    /** Request payload */
+    payload: unknown;
+    /** gRPC metadata */
+    metadata?: Record<string, string>;
+}
+/**
+ * WebSocket-specific request
+ */
+export interface WebSocketRequest extends BaseRequest {
+    /** WebSocket event type */
+    event: string;
+    /** Event data */
+    data: unknown;
+    /** Acknowledgement required */
+    ack?: boolean;
+    /** Acknowledgement timeout */
+    ackTimeout?: number;
+}
+/**
+ * Retry configuration for a request
+ */
+export interface RetryConfig {
+    /** Maximum number of retry attempts */
+    maxAttempts?: number;
+    /** Initial retry delay in milliseconds */
+    initialDelay?: number;
+    /** Maximum retry delay in milliseconds */
+    maxDelay?: number;
+    /** Backoff multiplier */
+    multiplier?: number;
+    /** Jitter factor (0-1) */
+    jitter?: number;
+    /** Retry on specific status codes */
+    retryOnStatus?: number[];
+    /** Retry on specific error types */
+    retryOnErrors?: string[];
+}
+/**
+ * Circuit breaker configuration for a specific request
+ */
+export interface CircuitBreakerRequestConfig {
+    /** Enable circuit breaker for this request */
+    enabled?: boolean;
+    /** Failure threshold before opening */
+    failureThreshold?: number;
+    /** Reset timeout in milliseconds */
+    resetTimeout?: number;
+    /** Half-open max attempts */
+    halfOpenMaxAttempts?: number;
+    /** Exclude this request from circuit breaker */
+    exclude?: boolean;
+}
+/**
+ * Union type of all request types
+ */
+export type Request = HttpRequest | GrpcRequest | WebSocketRequest;
+/**
+ * Request options for client calls
+ */
+export interface RequestOptions {
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Enable/disable retry */
+    retry?: boolean | RetryConfig;
+    /** Enable/disable circuit breaker */
+    circuitBreaker?: boolean | CircuitBreakerRequestConfig;
+    /** Request metadata */
+    metadata?: Record<string, unknown>;
+    /** Custom request ID */
+    requestId?: string;
+}
+/**
+ * Request context passed through interceptors
+ */
+export interface RequestContext {
+    /** Request ID */
+    requestId: string;
+    /** Service name */
+    serviceName: string;
+    /** Endpoint/URL */
+    endpoint: string;
+    /** Request start timestamp */
+    startTime: number;
+    /** Request attempt number */
+    attempt: number;
+    /** Is this a retry attempt? */
+    isRetry: boolean;
+    /** Previous error (if retrying) */
+    previousError?: Error;
+    /** Custom context data */
+    data?: Map<string, unknown>;
+}

package/dist/types/types/response.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Response types and interfaces for communication layer
+ * @packageDocumentation
+ */
+import type { HttpStatusCode } from '@naman_deep_singh/http-response';
+/**
+ * Base response interface for all protocols
+ */
+export interface BaseResponse<T = unknown> {
+    /** Response data */
+    data: T;
+    /** Response status code */
+    status: number;
+    /** Response status text */
+    statusText?: string;
+    /** Response headers */
+    headers?: Record<string, string>;
+    /** Response metadata */
+    metadata?: Record<string, unknown>;
+    /** Request duration in milliseconds */
+    duration?: number;
+    /** Request ID */
+    requestId?: string;
+    /** Is the response cached? */
+    cached?: boolean;
+    /** Cache age in milliseconds */
+    cacheAge?: number;
+}
+/**
+ * HTTP-specific response
+ */
+export interface HttpResponse<T = unknown> extends BaseResponse<T> {
+    /** HTTP status code */
+    status: HttpStatusCode;
+    /** Response URL */
+    url: string;
+    /** Redirected URL if any */
+    redirected?: boolean;
+    /** Response size in bytes */
+    size?: number;
+    /** Response type */
+    type?: 'basic' | 'cors' | 'default' | 'error' | 'opaque';
+}
+/**
+ * gRPC-specific response
+ */
+export interface GrpcResponse<T = unknown> extends BaseResponse<T> {
+    /** gRPC status code */
+    grpcCode: number;
+    /** gRPC status message */
+    grpcMessage?: string;
+    /** gRPC trailers */
+    trailers?: Record<string, string>;
+}
+/**
+ * WebSocket-specific response
+ */
+export interface WebSocketResponse<T = unknown> extends BaseResponse<T> {
+    /** WebSocket event type */
+    event: string;
+    /** Is this an acknowledgement? */
+    ack?: boolean;
+    /** Sequence number */
+    sequence?: number;
+}
+/**
+ * Error response interface
+ */
+export interface ErrorResponse {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: string;
+    /** HTTP status code */
+    status?: number;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+    /** Request ID */
+    requestId?: string;
+    /** Service name */
+    service?: string;
+    /** Endpoint */
+    endpoint?: string;
+    /** Stack trace (development only) */
+    stack?: string;
+    /** Retry information */
+    retry?: {
+        /** Current retry attempt */
+        attempt: number;
+        /** Maximum retry attempts */
+        maxAttempts: number;
+        /** Next retry delay in milliseconds */
+        nextDelay?: number;
+    };
+    /** Circuit breaker state if applicable */
+    circuitBreaker?: {
+        /** Circuit breaker state */
+        state: 'closed' | 'open' | 'half-open';
+        /** Failures count */
+        failures: number;
+        /** Next reset time */
+        nextReset?: number;
+    };
+}
+/**
+ * Paginated response interface
+ */
+export interface PaginatedResponse<T> {
+    /** Response data */
+    data: T[];
+    /** Pagination metadata */
+    pagination: {
+        /** Current page number */
+        page: number;
+        /** Items per page */
+        limit: number;
+        /** Total number of items */
+        total: number;
+        /** Total number of pages */
+        totalPages: number;
+        /** Has next page? */
+        hasNext: boolean;
+        /** Has previous page? */
+        hasPrev: boolean;
+        /** Next page URL */
+        next?: string;
+        /** Previous page URL */
+        prev?: string;
+    };
+    /** Response status */
+    status: number;
+    /** Response headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Streaming response interface
+ */
+export interface StreamResponse<T = unknown> {
+    /** Stream data */
+    data: AsyncIterable<T>;
+    /** Response headers */
+    headers?: Record<string, string>;
+    /** Response status */
+    status: number;
+    /** Request ID */
+    requestId?: string;
+    /** Close the stream */
+    close(): Promise<void>;
+    /** Cancel the stream */
+    cancel(): Promise<void>;
+}
+/**
+ * Union type of all response types
+ */
+export type Response<T = unknown> = HttpResponse<T> | GrpcResponse<T> | WebSocketResponse<T>;