@lobu/core 3.0.10 → 3.0.12

package/src/redis/base-store.ts

@@ -1,200 +0,0 @@
-import type Redis from "ioredis";
-import { createLogger, type Logger } from "../logger";
-import { safeJsonParse, safeJsonStringify } from "../utils/json";
-
-function errMsg(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-export interface RedisStoreConfig {
-  redis: Redis;
-  keyPrefix: string;
-  loggerName: string;
-}
-
-/**
- * Base class for all Redis-backed stores
- * Provides common CRUD operations with JSON serialization
- *
- * Consolidates:
- * - packages/gateway/src/auth/credential-store.ts (BaseCredentialStore)
- * - packages/gateway/src/infrastructure/redis/store.ts (BaseRedisStore)
- */
-export abstract class BaseRedisStore<T> {
-  protected logger: Logger;
-  protected redis: Redis;
-  protected keyPrefix: string;
-
-  constructor(config: RedisStoreConfig) {
-    this.redis = config.redis;
-    this.keyPrefix = config.keyPrefix;
-    this.logger = createLogger(config.loggerName);
-  }
-
-  /**
-   * Build Redis key from parts
-   */
-  protected buildKey(...parts: string[]): string {
-    return [this.keyPrefix, ...parts].join(":");
-  }
-
-  /**
-   * Get value from Redis
-   * Returns null if not found or validation fails
-   */
-  protected async get(key: string): Promise<T | null> {
-    try {
-      const data = await this.redis.get(key);
-      if (!data) {
-        return null;
-      }
-
-      const value = this.deserialize(data);
-
-      // Validate after deserialization
-      if (!this.validate(value)) {
-        this.logger.warn("Invalid data after deserialization", { key });
-        return null;
-      }
-
-      return value;
-    } catch (error) {
-      this.logger.error("Failed to get from Redis", {
-        error: errMsg(error),
-        key,
-      });
-      return null;
-    }
-  }
-
-  /**
-   * Set value in Redis
-   */
-  protected async set(
-    key: string,
-    value: T,
-    ttlSeconds?: number
-  ): Promise<void> {
-    try {
-      const data = this.serialize(value);
-      if (ttlSeconds) {
-        await this.redis.setex(key, ttlSeconds, data);
-      } else {
-        await this.redis.set(key, data);
-      }
-    } catch (error) {
-      this.logger.error("Failed to set in Redis", {
-        error: errMsg(error),
-        key,
-      });
-      throw error;
-    }
-  }
-
-  /**
-   * Delete value from Redis
-   */
-  protected async delete(key: string): Promise<void> {
-    try {
-      await this.redis.del(key);
-    } catch (error) {
-      this.logger.error("Failed to delete from Redis", {
-        error: errMsg(error),
-        key,
-      });
-    }
-  }
-
-  /**
-   * Scan for all keys matching a prefix (cursor-based, production-safe).
-   * Returns full key strings matching `{prefix}*`.
-   */
-  protected async scanByPrefix(prefix: string): Promise<string[]> {
-    const results: string[] = [];
-    let cursor = "0";
-    try {
-      do {
-        const [nextCursor, keys] = await this.redis.scan(
-          cursor,
-          "MATCH",
-          `${prefix}*`,
-          "COUNT",
-          100
-        );
-        cursor = nextCursor;
-        results.push(...keys);
-      } while (cursor !== "0");
-    } catch (error) {
-      this.logger.error("Failed to scan by prefix", {
-        error: errMsg(error),
-        prefix,
-      });
-    }
-    return results;
-  }
-
-  /**
-   * Check if key exists in Redis
-   */
-  protected async exists(key: string): Promise<boolean> {
-    try {
-      const result = await this.redis.exists(key);
-      return result === 1;
-    } catch (error) {
-      this.logger.error("Failed to check existence in Redis", {
-        error: errMsg(error),
-        key,
-      });
-      return false;
-    }
-  }
-
-  /**
-   * Serialize value to string
-   * Override for custom serialization
-   */
-  protected serialize(value: T): string {
-    const result = safeJsonStringify(value);
-    if (result === null) {
-      throw new Error("Failed to serialize value to JSON");
-    }
-    return result;
-  }
-
-  /**
-   * Deserialize string to value
-   * Override for custom deserialization
-   */
-  protected deserialize(data: string): T {
-    const result = safeJsonParse<T>(data);
-    if (result === null) {
-      throw new Error("Failed to deserialize JSON data");
-    }
-    return result;
-  }
-
-  /**
-   * Validate value after deserialization
-   * Override to add custom validation logic
-   * Return false to reject invalid data
-   */
-  protected validate(_value: T): boolean {
-    return true;
-  }
-}
-
-/**
- * Specialized base for credential stores
- * Validates that accessToken field exists
- */
-export abstract class BaseCredentialStore<
-  T extends { accessToken: string },
-> extends BaseRedisStore<T> {
-  protected override validate(value: T): boolean {
-    if (!value.accessToken) {
-      this.logger.warn("Invalid credentials: missing accessToken");
-      return false;
-    }
-    return true;
-  }
-}

package/src/sentry.ts

@@ -1,56 +0,0 @@
-import { createLogger, type Logger } from "./logger";
-
-// Lazy logger initialization to avoid circular dependency
-let _logger: Logger | null = null;
-function getLogger(): Logger {
-  if (!_logger) {
-    _logger = createLogger("sentry");
-  }
-  return _logger;
-}
-
-let sentryInstance: typeof import("@sentry/node") | null = null;
-
-/**
- * Initialize Sentry with configuration from environment variables.
- * Only initializes if SENTRY_DSN is set — no implicit error reporting.
- * Uses dynamic import to avoid module resolution issues in dev mode.
- */
-export async function initSentry() {
-  const sentryDsn = process.env.SENTRY_DSN;
-  if (!sentryDsn) {
-    getLogger().debug("Sentry disabled (no SENTRY_DSN configured)");
-    return;
-  }
-
-  try {
-    const Sentry = await import("@sentry/node");
-    sentryInstance = Sentry;
-
-    Sentry.init({
-      dsn: sentryDsn,
-      sendDefaultPii: true,
-      profileSessionSampleRate: 1.0,
-      tracesSampleRate: 1.0, // Capture 100% of traces for better visibility
-      integrations: [
-        Sentry.consoleLoggingIntegration({ levels: ["log", "warn", "error"] }),
-        Sentry.redisIntegration(),
-      ],
-    });
-
-    getLogger().debug("Sentry monitoring initialized");
-  } catch (error) {
-    getLogger().warn(
-      "Sentry initialization failed (continuing without monitoring):",
-      error
-    );
-  }
-}
-
-/**
- * Get the initialized Sentry instance
- * @returns Sentry instance or null if not initialized
- */
-export function getSentry(): typeof import("@sentry/node") | null {
-  return sentryInstance;
-}

package/src/trace.ts

@@ -1,32 +0,0 @@
-/**
- * Trace ID utilities for end-to-end message lifecycle observability.
- * Trace IDs propagate through the entire pipeline:
- * [WhatsApp Message] -> [Queue] -> [Worker Creation] -> [PVC Setup] -> [Agent Runtime] -> [Response]
- *
- * When OpenTelemetry is initialized, spans are sent to Tempo for waterfall visualization.
- * Use createSpan/createChildSpan from ./otel.ts for actual span creation.
- */
-
-/**
- * Generate a trace ID from a message ID.
- * Format: tr-{messageId prefix}-{timestamp base36}-{random}
- * Example: tr-abc12345-lx4k-a3b2
- */
-export function generateTraceId(messageId: string): string {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 6);
-  // Take first 8 chars of messageId, sanitize for safe logging
-  const shortMessageId = messageId.replace(/[^a-zA-Z0-9]/g, "").substring(0, 8);
-  return `tr-${shortMessageId}-${timestamp}-${random}`;
-}
-
-/**
- * Extract trace ID from various payload formats.
- * Checks both top-level and nested platformMetadata.
- */
-export function extractTraceId(payload: {
-  traceId?: string;
-  platformMetadata?: { traceId?: string };
-}): string | undefined {
-  return payload?.traceId || payload?.platformMetadata?.traceId;
-}