@ceschiatti/redistail 0.0.2 → 0.0.4

package/src/cli/pubsub-monitor-service.ts

@@ -0,0 +1,296 @@
+/**
+ * PubSub monitoring service for the redistail CLI utility.
+ *
+ * This service provides Redis Pub/Sub channel monitoring capabilities with
+ * automatic reconnection, exponential backoff, and proper error handling.
+ * It integrates with the effect-redis RedisPubSub service and follows
+ * Effect-TS patterns for dependency injection and resource management.
+ */
+
+import {
+  Context,
+  Effect,
+  Layer,
+  Schedule,
+  Stream,
+  pipe,
+  Duration,
+} from 'effect';
+import { RedisPubSub } from 'effect-redis';
+import {
+  type PubSubMessage,
+  type RedistailConfig,
+  type MonitoringError,
+  type ConfigError,
+  PubSubMessage as PubSubMessageConstructor,
+  createConnectionLostError,
+  createSubscriptionFailedError,
+} from './types';
+import { CLIConfigService } from './config-service';
+import type { RedisError } from 'effect-redis';
+
+// Get the service type from the Context.Tag
+type RedisPubSubService = Context.Tag.Service<RedisPubSub>;
+
+// ============================================================================
+// Service Interface
+// ============================================================================
+
+/**
+ * Service interface for PubSub monitoring operations
+ */
+export interface PubSubMonitorService {
+  /**
+   * Monitor a Redis Pub/Sub channel with automatic reconnection
+   * @param channel - The channel name to monitor
+   * @returns Stream of PubSub messages with error handling and reconnection
+   */
+  readonly monitor: (
+    channel: string,
+  ) => Stream.Stream<PubSubMessage, MonitoringError>;
+
+  /**
+   * Subscribe to a Redis Pub/Sub channel
+   * @param channel - The channel name to subscribe to
+   * @returns Effect that yields a stream of PubSub messages
+   */
+  readonly subscribe: (
+    channel: string,
+  ) => Effect.Effect<
+    Stream.Stream<PubSubMessage, MonitoringError>,
+    MonitoringError
+  >;
+}
+
+/**
+ * Context tag for PubSub monitoring service dependency injection
+ */
+export const PubSubMonitorService = Context.GenericTag<PubSubMonitorService>(
+  'PubSubMonitorService',
+);
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Convert RedisError to MonitoringError
+ */
+const convertRedisError = (
+  error: RedisError,
+  context: string,
+): MonitoringError => {
+  return createSubscriptionFailedError(
+    `${context}: ${error.message}`,
+    true,
+    error,
+  );
+};
+
+// ============================================================================
+// Service Implementation
+// ============================================================================
+
+/**
+ * Creates a PubSub monitor service implementation
+ */
+const createPubSubMonitorService = (
+  redisPubSubService: RedisPubSubService,
+  config: RedistailConfig,
+): PubSubMonitorService => ({
+  monitor: (channel: string) =>
+    pipe(
+      // Create the base subscription stream
+      Effect.mapError(
+        redisPubSubService.subscribe(channel),
+        (error: RedisError) =>
+          convertRedisError(
+            error,
+            `Failed to subscribe to channel '${channel}'`,
+          ),
+      ),
+      // Convert Effect to Stream
+      Stream.unwrap,
+      // Transform Redis messages to PubSubMessage format
+      Stream.map((content: string) =>
+        PubSubMessageConstructor({
+          timestamp: new Date(),
+          channel,
+          content,
+        }),
+      ),
+      // Handle stream errors and convert to MonitoringError
+      Stream.mapError((error: Error) =>
+        createConnectionLostError(
+          `Connection lost while monitoring channel '${channel}': ${error.message}`,
+          error,
+        ),
+      ),
+      // Add automatic reconnection with exponential backoff
+      Stream.retry(
+        pipe(
+          Schedule.exponential(Duration.seconds(1)),
+          Schedule.intersect(
+            Schedule.recurs(config.monitoring.maxReconnectAttempts),
+          ),
+          Schedule.tapInput((error: MonitoringError) =>
+            Effect.logWarning(
+              `PubSub monitoring error for channel '${channel}': ${error.message}. Retrying...`,
+            ),
+          ),
+        ),
+      ),
+      // Handle final failure after max retries
+      Stream.catchAll((error: MonitoringError) =>
+        Stream.fail(
+          createSubscriptionFailedError(
+            `Failed to monitor channel '${channel}' after ${config.monitoring.maxReconnectAttempts} attempts: ${error.message}`,
+            false, // Not retryable after max attempts
+            error,
+          ),
+        ),
+      ),
+    ),
+
+  subscribe: (channel: string) =>
+    Effect.gen(function* () {
+      // Attempt to subscribe to the channel
+      const messageStream = yield* Effect.mapError(
+        redisPubSubService.subscribe(channel),
+        (error: RedisError) =>
+          convertRedisError(
+            error,
+            `Failed to subscribe to channel '${channel}'`,
+          ),
+      );
+
+      // Transform the stream to PubSubMessage format
+      return pipe(
+        messageStream,
+        Stream.map((content: string) =>
+          PubSubMessageConstructor({
+            timestamp: new Date(),
+            channel,
+            content,
+          }),
+        ),
+        // Handle stream errors
+        Stream.mapError((error: Error) =>
+          createConnectionLostError(
+            `Stream error for channel '${channel}': ${error.message}`,
+            error,
+          ),
+        ),
+      );
+    }),
+});
+
+// ============================================================================
+// Live Layer Implementation
+// ============================================================================
+
+/**
+ * Live layer for PubSub monitoring service
+ * Depends on RedisPubSub and CLIConfigService services
+ */
+export const PubSubMonitorServiceLive: Layer.Layer<
+  PubSubMonitorService,
+  ConfigError,
+  RedisPubSub | CLIConfigService
+> = Layer.effect(
+  PubSubMonitorService,
+  Effect.gen(function* () {
+    const redisPubSubService = yield* RedisPubSub;
+    const configService = yield* CLIConfigService;
+    const config = yield* configService.loadConfig();
+    return createPubSubMonitorService(redisPubSubService, config);
+  }),
+);
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+/**
+ * Helper function to create a monitoring stream with custom retry configuration
+ */
+export const createMonitoringStreamWithRetry = (
+  channel: string,
+  redisPubSubService: RedisPubSubService,
+  maxRetries: number,
+  baseDelaySeconds = 1,
+): Stream.Stream<PubSubMessage, MonitoringError> =>
+  pipe(
+    Effect.mapError(
+      redisPubSubService.subscribe(channel),
+      (error: RedisError) =>
+        convertRedisError(error, `Failed to subscribe to channel '${channel}'`),
+    ),
+    Stream.unwrap,
+    Stream.map((content: string) =>
+      PubSubMessageConstructor({
+        timestamp: new Date(),
+        channel,
+        content,
+      }),
+    ),
+    Stream.mapError((error: Error) =>
+      createConnectionLostError(
+        `Connection lost while monitoring channel '${channel}': ${error.message}`,
+        error,
+      ),
+    ),
+    Stream.retry(
+      pipe(
+        Schedule.exponential(Duration.seconds(baseDelaySeconds)),
+        Schedule.intersect(Schedule.recurs(maxRetries)),
+        Schedule.tapInput((error: MonitoringError) =>
+          Effect.logWarning(
+            `PubSub monitoring error for channel '${channel}': ${error.message}. Retrying...`,
+          ),
+        ),
+      ),
+    ),
+  );
+
+/**
+ * Helper function to validate channel names
+ */
+export const validateChannelName = (
+  channel: string,
+): Effect.Effect<string, MonitoringError> =>
+  Effect.gen(function* () {
+    if (!channel || typeof channel !== 'string') {
+      return yield* Effect.fail(
+        createSubscriptionFailedError(
+          'Channel name must be a non-empty string',
+          false,
+        ),
+      );
+    }
+
+    const trimmedChannel = channel.trim();
+    if (trimmedChannel.length === 0) {
+      return yield* Effect.fail(
+        createSubscriptionFailedError(
+          'Channel name cannot be empty or whitespace only',
+          false,
+        ),
+      );
+    }
+
+    return trimmedChannel;
+  });
+
+/**
+ * Helper function to create a monitored channel with validation
+ */
+export const monitorChannelWithValidation = (
+  channel: string,
+  pubSubService: PubSubMonitorService,
+): Stream.Stream<PubSubMessage, MonitoringError> =>
+  pipe(
+    validateChannelName(channel),
+    Effect.map((validChannel) => pubSubService.monitor(validChannel)),
+    Stream.unwrap,
+  );

package/src/cli/redistail-launcher.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * Cross-platform launcher for redistail CLI
+ * Detects platform and runs the appropriate binary
+ */
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function launchRedistail() {
+  const args = process.argv.slice(2);
+
+  // Try to use the compiled executable first (better performance)
+  const exePath = join(__dirname, 'redistail.exe');
+  const jsPath = join(__dirname, 'redistail.js');
+
+  let command;
+  let commandArgs;
+
+  if (process.platform === 'win32' && existsSync(exePath)) {
+    // Use the compiled executable on Windows
+    command = exePath;
+    commandArgs = args;
+  } else if (existsSync(jsPath)) {
+    // Fall back to Node.js execution
+    command = 'node';
+    commandArgs = [jsPath, ...args];
+  } else {
+    console.error('Error: redistail binary not found');
+    process.exit(1);
+  }
+
+  // Spawn the process and pipe stdio
+  const child = spawn(command, commandArgs, {
+    stdio: 'inherit',
+    windowsHide: false,
+  });
+
+  // Handle process exit
+  child.on('close', (code) => {
+    process.exit(code || 0);
+  });
+
+  child.on('error', (error) => {
+    console.error('Error launching redistail:', error.message);
+    process.exit(1);
+  });
+
+  // Handle process signals
+  process.on('SIGINT', () => {
+    child.kill('SIGINT');
+  });
+
+  process.on('SIGTERM', () => {
+    child.kill('SIGTERM');
+  });
+}
+
+launchRedistail();