@windrun-huaiin/backend-core 13.0.0 → 14.1.0

package/src/lib/upstash/redis-structures.ts

@@ -1,4 +1,4 @@
-import { getRedis } from '../upstash-config';
+import { withRedis } from '../upstash-config';
 
 /**
  * Set a plain string value with optional TTL (seconds).
@@ -8,30 +8,22 @@ export const setString = async (
   value: string,
   ttlSec?: number
 ): Promise<boolean> => {
-  const redis = getRedis();
-  if (!redis) {
-    return false;
-  }
+  return withRedis(async (redis) => {
+    if (ttlSec && ttlSec > 0) {
+      await redis.set(key, value, { ex: ttlSec });
+      return true;
+    }
 
-  if (ttlSec && ttlSec > 0) {
-    await redis.set(key, value, { ex: ttlSec });
+    await redis.set(key, value);
     return true;
-  }
-
-  await redis.set(key, value);
-  return true;
+  }).then((result) => result ?? false);
 };
 
 /**
  * Get a plain string value. Returns null if Redis is unavailable or key missing.
  */
 export const getString = async (key: string): Promise<string | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.get<string>(key);
+  return withRedis((redis) => redis.get<string>(key));
 };
 
 /**
@@ -42,78 +34,63 @@ export const setJson = async <T>(
   value: T,
   ttlSec?: number
 ): Promise<boolean> => {
-  const redis = getRedis();
-  if (!redis) {
-    return false;
-  }
-
-  const payload = JSON.stringify(value);
-  if (ttlSec && ttlSec > 0) {
-    await redis.set(key, payload, { ex: ttlSec });
+  return withRedis(async (redis) => {
+    const payload = JSON.stringify(value);
+    if (ttlSec && ttlSec > 0) {
+      await redis.set(key, payload, { ex: ttlSec });
+      return true;
+    }
+
+    await redis.set(key, payload);
     return true;
-  }
-
-  await redis.set(key, payload);
-  return true;
+  }).then((result) => result ?? false);
 };
 
 /**
  * Get an object stored as JSON string. Returns null if missing or invalid JSON.
  */
 export const getJson = async <T>(key: string): Promise<T | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const payload = await redis.get<string>(key);
-  if (!payload) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(payload) as T;
-  } catch {
-    return null;
-  }
+  return withRedis(async (redis) => {
+    const payload = await redis.get<string>(key);
+    if (!payload) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(payload) as T;
+    } catch {
+      return null;
+    }
+  });
 };
 
 /**
  * Delete a key. Returns false if Redis is unavailable.
  */
 export const deleteKey = async (key: string): Promise<boolean> => {
-  const redis = getRedis();
-  if (!redis) {
-    return false;
-  }
-
-  const deleted = await redis.del(key);
-  return deleted > 0;
+  const result = await withRedis(async (redis) => {
+    const deleted = await redis.del(key);
+    return deleted > 0;
+  });
+  return result ?? false;
 };
 
 /**
  * Set a hash field value.
  */
 export const setHashField = async (key: string, field: string, value: string): Promise<boolean> => {
-  const redis = getRedis();
-  if (!redis) {
-    return false;
-  }
-
-  const result = await redis.hset(key, { [field]: value });
-  return result > 0;
+  const result = await withRedis(async (redis) => {
+    const changed = await redis.hset(key, { [field]: value });
+    return changed > 0;
+  });
+  return result ?? false;
 };
 
 /**
  * Get a hash field value.
  */
 export const getHashField = async (key: string, field: string): Promise<string | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.hget<string>(key, field);
+  return withRedis((redis) => redis.hget<string>(key, field));
 };
 
 /**
@@ -124,61 +101,51 @@ export const setHashJson = async <T>(
   field: string,
   value: T
 ): Promise<boolean> => {
-  const redis = getRedis();
-  if (!redis) {
-    return false;
-  }
-
-  const payload = JSON.stringify(value);
-  const result = await redis.hset(key, { [field]: payload });
-  return result > 0;
+  const result = await withRedis(async (redis) => {
+    const payload = JSON.stringify(value);
+    const changed = await redis.hset(key, { [field]: payload });
+    return changed > 0;
+  });
+  return result ?? false;
 };
 
 /**
  * Get a hash field stored as JSON string.
  */
 export const getHashJson = async <T>(key: string, field: string): Promise<T | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const payload = await redis.hget<string>(key, field);
-  if (!payload) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(payload) as T;
-  } catch {
-    return null;
-  }
+  return withRedis(async (redis) => {
+    const payload = await redis.hget<string>(key, field);
+    if (!payload) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(payload) as T;
+    } catch {
+      return null;
+    }
+  });
 };
 
 /**
  * Get all hash fields.
  */
 export const getHashAll = async (key: string): Promise<Record<string, string> | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const result = await redis.hgetall<Record<string, string>>(key);
-  return result ?? {};
+  return withRedis(async (redis) => {
+    const result = await redis.hgetall<Record<string, string>>(key);
+    return result ?? {};
+  });
 };
 
 /**
  * Remove a hash field.
  */
 export const deleteHashField = async (key: string, field: string): Promise<boolean> => {
-  const redis = getRedis();
-  if (!redis) {
-    return false;
-  }
-
-  const removed = await redis.hdel(key, field);
-  return removed > 0;
+  const result = await withRedis(async (redis) => {
+    const removed = await redis.hdel(key, field);
+    return removed > 0;
+  });
+  return result ?? false;
 };
 
 type ListDirection = 'left' | 'right';
@@ -191,18 +158,15 @@ export const pushList = async (
   values: string[],
   direction: ListDirection = 'right'
 ): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  if (values.length === 0) {
-    return redis.llen(key);
-  }
-
-  return direction === 'left'
-    ? redis.lpush(key, ...values)
-    : redis.rpush(key, ...values);
+  return withRedis((redis) => {
+    if (values.length === 0) {
+      return redis.llen(key);
+    }
+
+    return direction === 'left'
+      ? redis.lpush(key, ...values)
+      : redis.rpush(key, ...values);
+  });
 };
 
 /**
@@ -212,12 +176,9 @@ export const popList = async (
   key: string,
   direction: ListDirection = 'right'
 ): Promise<string | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return direction === 'left' ? redis.lpop<string>(key) : redis.rpop<string>(key);
+  return withRedis((redis) =>
+    direction === 'left' ? redis.lpop<string>(key) : redis.rpop<string>(key)
+  );
 };
 
 /**
@@ -228,22 +189,12 @@ export const rangeList = async (
   start = 0,
   stop = -1
 ): Promise<string[] | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.lrange<string>(key, start, stop);
+  return withRedis((redis) => redis.lrange<string>(key, start, stop));
 };
 
 /**
  * Get list length.
  */
 export const listLength = async (key: string): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.llen(key);
+  return withRedis((redis) => redis.llen(key));
 };

package/src/lib/upstash-config.ts

@@ -3,52 +3,259 @@ import { Client as QstashClient } from '@upstash/qstash';
 
 let cachedRedis: Redis | null = null;
 let cachedQstash: QstashClient | null = null;
-let redisInitAttempted = false;
-let qstashInitAttempted = false;
+let redisInitPromise: Promise<Redis | null> | null = null;
+let qstashInitPromise: Promise<QstashClient | null> | null = null;
+
+let redisWarnedMissingEnv = false;
+let redisWarnedInvalidEnv = false;
+let redisWarnedInitError = false;
+let redisWarnedHealthCheck = false;
+let redisWarnedHealthSchedule = false;
+
+let qstashWarnedMissingEnv = false;
+let qstashWarnedInitError = false;
+let qstashWarnedHealthCheck = false;
+let qstashWarnedHealthSchedule = false;
+
+let redisHealthTimer: ReturnType<typeof setTimeout> | null = null;
+let qstashHealthTimer: ReturnType<typeof setTimeout> | null = null;
+
+const isNonEmpty = (value: string | undefined): value is string =>
+  typeof value === 'string' && value.trim().length > 0;
+
+const isValidUrl = (value: string): boolean => {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+  } catch {
+    return false;
+  }
+};
+
+const parseMinutes = (value: string | undefined, fallback: number): number => {
+  if (!isNonEmpty(value)) {
+    return fallback;
+  }
+  const minutes = Number(value);
+  if (!Number.isFinite(minutes) || minutes <= 0) {
+    return fallback;
+  }
+  return minutes;
+};
+
+const getRedisHealthIntervalMinutes = (): number =>
+  parseMinutes(process.env.UPSTASH_REDIS_HEALTHCHECK_INTERVAL_MINUTES, 10);
+
+const getQstashHealthIntervalMinutes = (): number =>
+  parseMinutes(process.env.UPSTASH_QSTASH_HEALTHCHECK_INTERVAL_MINUTES, 10);
+
+const getQstashHealthcheckUrl = (): string =>
+  process.env.UPSTASH_QSTASH_HEALTHCHECK_URL ?? 'https://qstash.upstash.io/v2/topics';
+
+const scheduleRedisHealthCheck = (): void => {
+  if (redisHealthTimer || !cachedRedis) {
+    return;
+  }
+  const delayMs = getRedisHealthIntervalMinutes() * 60_000;
+  redisHealthTimer = setTimeout(async () => {
+    redisHealthTimer = null;
+    if (!cachedRedis) {
+      return;
+    }
+    try {
+      await cachedRedis.ping();
+    } catch (error) {
+      cachedRedis = null;
+      if (!redisWarnedHealthCheck) {
+        redisWarnedHealthCheck = true;
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[Upstash Config] Redis health check failed: ${message}`);
+      }
+    } finally {
+      try {
+        scheduleRedisHealthCheck();
+      } catch (error) {
+        if (!redisWarnedHealthSchedule) {
+          redisWarnedHealthSchedule = true;
+          const message = error instanceof Error ? error.message : String(error);
+          console.warn(`[Upstash Config] Redis health check schedule failed: ${message}`);
+        }
+      }
+    }
+  }, delayMs);
+};
+
+const checkQstashHealth = async (token: string): Promise<void> => {
+  const response = await fetch(getQstashHealthcheckUrl(), {
+    method: 'GET',
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+    cache: 'no-store',
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+};
+
+const scheduleQstashHealthCheck = (token: string): void => {
+  if (qstashHealthTimer || !cachedQstash) {
+    return;
+  }
+  const delayMs = getQstashHealthIntervalMinutes() * 60_000;
+  qstashHealthTimer = setTimeout(async () => {
+    qstashHealthTimer = null;
+    if (!cachedQstash) {
+      return;
+    }
+    try {
+      await checkQstashHealth(token);
+    } catch (error) {
+      cachedQstash = null;
+      if (!qstashWarnedHealthCheck) {
+        qstashWarnedHealthCheck = true;
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[Upstash Config] QStash health check failed: ${message}`);
+      }
+    } finally {
+      try {
+        scheduleQstashHealthCheck(token);
+      } catch (error) {
+        if (!qstashWarnedHealthSchedule) {
+          qstashWarnedHealthSchedule = true;
+          const message = error instanceof Error ? error.message : String(error);
+          console.warn(`[Upstash Config] QStash health check schedule failed: ${message}`);
+        }
+      }
+    }
+  }, delayMs);
+};
 
 /**
- * Get the Upstash Redis client. Returns null when required env vars are missing.
+ * Get the Upstash Redis client. Returns null when required env vars are missing/invalid.
+ *
+ * Singleton semantics:
+ * - read-through cached instance only
  */
 export const getRedis = (): Redis | null => {
+  return cachedRedis;
+};
+
+const ensureRedis = async (): Promise<Redis | null> => {
   if (cachedRedis) {
     return cachedRedis;
   }
-  if (redisInitAttempted) {
-    return null;
+  if (redisInitPromise) {
+    return redisInitPromise;
   }
 
-  redisInitAttempted = true;
-  const { UPSTASH_REDIS_REST_URL, UPSTASH_REDIS_REST_TOKEN } = process.env;
-  if (!UPSTASH_REDIS_REST_URL || !UPSTASH_REDIS_REST_TOKEN) {
-    console.warn('[Upstash Config] Redis Missed configration UPSTASH_REDIS_REST_URL or UPSTASH_REDIS_REST_TOKEN, then disabled');
-    return null;
-  }
+  redisInitPromise = (async () => {
+    const { UPSTASH_REDIS_REST_URL, UPSTASH_REDIS_REST_TOKEN } = process.env;
+    if (!isNonEmpty(UPSTASH_REDIS_REST_URL) || !isNonEmpty(UPSTASH_REDIS_REST_TOKEN)) {
+      if (!redisWarnedMissingEnv) {
+        redisWarnedMissingEnv = true;
+        console.warn(
+          '[Upstash Config] Redis disabled: missing UPSTASH_REDIS_REST_URL or UPSTASH_REDIS_REST_TOKEN'
+        );
+      }
+      return null;
+    }
 
-  cachedRedis = new Redis({
-    url: UPSTASH_REDIS_REST_URL,
-    token: UPSTASH_REDIS_REST_TOKEN,
-  });
-  return cachedRedis;
+    if (!isValidUrl(UPSTASH_REDIS_REST_URL)) {
+      if (!redisWarnedInvalidEnv) {
+        redisWarnedInvalidEnv = true;
+        console.warn('[Upstash Config] Redis disabled: UPSTASH_REDIS_REST_URL is not a valid URL');
+      }
+      return null;
+    }
+
+    try {
+      const client = new Redis({
+        url: UPSTASH_REDIS_REST_URL,
+        token: UPSTASH_REDIS_REST_TOKEN,
+      });
+      await client.ping();
+      cachedRedis = client;
+      scheduleRedisHealthCheck();
+      return cachedRedis;
+    } catch (error) {
+      if (!redisWarnedInitError) {
+        redisWarnedInitError = true;
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[Upstash Config] Redis init failed: ${message}`);
+      }
+      return null;
+    } finally {
+      redisInitPromise = null;
+    }
+  })();
+
+  return redisInitPromise;
 };
 
 /**
  * Get the Upstash QStash client. Returns null when required env vars are missing.
+ *
+ * Singleton semantics:
+ * - read-through cached instance only
  */
 export const getQstash = (): QstashClient | null => {
+  return cachedQstash;
+};
+
+const ensureQstash = async (): Promise<QstashClient | null> => {
   if (cachedQstash) {
     return cachedQstash;
   }
-  if (qstashInitAttempted) {
-    return null;
+  if (qstashInitPromise) {
+    return qstashInitPromise;
   }
 
-  qstashInitAttempted = true;
-  const { QSTASH_TOKEN } = process.env;
-  if (!QSTASH_TOKEN) {
-    console.warn('[Upstash Config] QStash Missed configration QSTASH_TOKEN, then disabled');
+  qstashInitPromise = (async () => {
+    const { QSTASH_TOKEN } = process.env;
+    if (!isNonEmpty(QSTASH_TOKEN)) {
+      if (!qstashWarnedMissingEnv) {
+        qstashWarnedMissingEnv = true;
+        console.warn('[Upstash Config] QStash disabled: missing QSTASH_TOKEN');
+      }
+      return null;
+    }
+
+    try {
+      const client = new QstashClient({ token: QSTASH_TOKEN });
+      await checkQstashHealth(QSTASH_TOKEN);
+      cachedQstash = client;
+      scheduleQstashHealthCheck(QSTASH_TOKEN);
+      return cachedQstash;
+    } catch (error) {
+      if (!qstashWarnedInitError) {
+        qstashWarnedInitError = true;
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[Upstash Config] QStash init failed: ${message}`);
+      }
+      return null;
+    } finally {
+      qstashInitPromise = null;
+    }
+  })();
+
+  return qstashInitPromise;
+};
+
+export const withRedis = async <T>(fn: (redis: Redis) => Promise<T> | T): Promise<T | null> => {
+  const redis = await ensureRedis();
+  if (!redis) {
     return null;
   }
+  return fn(redis);
+};
 
-  cachedQstash = new QstashClient({ token: QSTASH_TOKEN });
-  return cachedQstash;
+export const withQstash = async <T>(
+  fn: (qstash: QstashClient) => Promise<T> | T
+): Promise<T | null> => {
+  const qstash = await ensureQstash();
+  if (!qstash) {
+    return null;
+  }
+  return fn(qstash);
 };

package/src/services/stripe/webhook-handler.ts

@@ -13,7 +13,7 @@ import {
 import { Transaction } from '@/db/prisma-model-type';
 import { oneTimeExpiredDays } from '@/lib/credit-init';
 import { getCreditsFromPriceId } from '@/lib/money-price-config';
-import { fetchPaymentId, stripe } from '@/lib/stripe-config';
+import { fetchPaymentId, getStripe } from '@/lib/stripe-config';
 import Stripe from 'stripe';
 import { viewLocalTime } from '@windrun-huaiin/lib/utils';
 
@@ -150,6 +150,7 @@ async function handleSubscriptionCheckoutInit(
   }
 
   const subscriptionId = session.subscription as string;
+  const stripe = getStripe();
 
   // ===== STEP 1: FETCH EXTERNAL API DATA (BEFORE TRANSACTION) =====
   // 2. Get COMPLETE Stripe subscription details including billing period
@@ -416,6 +417,7 @@ async function handleSubscriptionDeleted(stripeSubscription: Stripe.Subscription
 
 async function handleAsyncPaymentSucceeded(session: Stripe.Checkout.Session) {
   console.log(`Async payment succeeded: ${session.id}`);
+  const stripe = getStripe();
 
   // Retrieve the latest session state to ensure payment_status is up to date
   const latestSession = await stripe.checkout.sessions.retrieve(session.id);

package/dist/_virtual/index3.js

@@ -1,5 +0,0 @@
-'use strict';
-
-var cryptoJs = {exports: {}};
-
-exports.__module = cryptoJs;

package/dist/_virtual/index3.mjs

@@ -1,3 +0,0 @@
-var cryptoJs = {exports: {}};
-
-export { cryptoJs as __module };