@windrun-huaiin/backend-core 13.0.0 → 14.1.0

package/dist/lib/upstash-config.mjs

@@ -1,50 +1,242 @@
-import { Redis as Redis2 } from '../node_modules/.pnpm/@upstash_redis@1.36.1/node_modules/@upstash/redis/nodejs.mjs';
-import { Client } from '../node_modules/.pnpm/@upstash_qstash@2.8.4/node_modules/@upstash/qstash/chunk-RQPZUJXG.mjs';
+import { __awaiter } from '../node_modules/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.46.2_tslib@2.8.1_typescript@5.9.3/node_modules/tslib/tslib.es6.mjs';
+import { Redis as Redis2 } from '../node_modules/.pnpm/@upstash_redis@1.37.0/node_modules/@upstash/redis/nodejs.mjs';
+import { Client } from '../node_modules/.pnpm/@upstash_qstash@2.10.1/node_modules/@upstash/qstash/chunk-35B33QW3.mjs';
 
 let cachedRedis = null;
 let cachedQstash = null;
-let redisInitAttempted = false;
-let qstashInitAttempted = false;
+let redisInitPromise = null;
+let qstashInitPromise = 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 = null;
+let qstashHealthTimer = null;
+const isNonEmpty = (value) => typeof value === 'string' && value.trim().length > 0;
+const isValidUrl = (value) => {
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    }
+    catch (_a) {
+        return false;
+    }
+};
+const parseMinutes = (value, fallback) => {
+    if (!isNonEmpty(value)) {
+        return fallback;
+    }
+    const minutes = Number(value);
+    if (!Number.isFinite(minutes) || minutes <= 0) {
+        return fallback;
+    }
+    return minutes;
+};
+const getRedisHealthIntervalMinutes = () => parseMinutes(process.env.UPSTASH_REDIS_HEALTHCHECK_INTERVAL_MINUTES, 10);
+const getQstashHealthIntervalMinutes = () => parseMinutes(process.env.UPSTASH_QSTASH_HEALTHCHECK_INTERVAL_MINUTES, 10);
+const getQstashHealthcheckUrl = () => { var _a; return (_a = process.env.UPSTASH_QSTASH_HEALTHCHECK_URL) !== null && _a !== void 0 ? _a : 'https://qstash.upstash.io/v2/topics'; };
+const scheduleRedisHealthCheck = () => {
+    if (redisHealthTimer || !cachedRedis) {
+        return;
+    }
+    const delayMs = getRedisHealthIntervalMinutes() * 60000;
+    redisHealthTimer = setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+        redisHealthTimer = null;
+        if (!cachedRedis) {
+            return;
+        }
+        try {
+            yield 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 = (token) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(getQstashHealthcheckUrl(), {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+        cache: 'no-store',
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+    }
+});
+const scheduleQstashHealthCheck = (token) => {
+    if (qstashHealthTimer || !cachedQstash) {
+        return;
+    }
+    const delayMs = getQstashHealthIntervalMinutes() * 60000;
+    qstashHealthTimer = setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+        qstashHealthTimer = null;
+        if (!cachedQstash) {
+            return;
+        }
+        try {
+            yield 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
  */
 const getRedis = () => {
+    return cachedRedis;
+};
+const ensureRedis = () => __awaiter(void 0, void 0, void 0, function* () {
     if (cachedRedis) {
         return cachedRedis;
     }
-    if (redisInitAttempted) {
-        return null;
-    }
-    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;
+    if (redisInitPromise) {
+        return redisInitPromise;
     }
-    cachedRedis = new Redis2({
-        url: UPSTASH_REDIS_REST_URL,
-        token: UPSTASH_REDIS_REST_TOKEN,
-    });
-    return cachedRedis;
-};
+    redisInitPromise = (() => __awaiter(void 0, void 0, void 0, function* () {
+        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;
+        }
+        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 Redis2({
+                url: UPSTASH_REDIS_REST_URL,
+                token: UPSTASH_REDIS_REST_TOKEN,
+            });
+            yield 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
  */
 const getQstash = () => {
+    return cachedQstash;
+};
+const ensureQstash = () => __awaiter(void 0, void 0, void 0, function* () {
     if (cachedQstash) {
         return cachedQstash;
     }
-    if (qstashInitAttempted) {
+    if (qstashInitPromise) {
+        return qstashInitPromise;
+    }
+    qstashInitPromise = (() => __awaiter(void 0, void 0, void 0, function* () {
+        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 Client({ token: QSTASH_TOKEN });
+            yield 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;
+});
+const withRedis = (fn) => __awaiter(void 0, void 0, void 0, function* () {
+    const redis = yield ensureRedis();
+    if (!redis) {
         return null;
     }
-    qstashInitAttempted = true;
-    const { QSTASH_TOKEN } = process.env;
-    if (!QSTASH_TOKEN) {
-        console.warn('[Upstash Config] QStash Missed configration QSTASH_TOKEN, then disabled');
+    return fn(redis);
+});
+const withQstash = (fn) => __awaiter(void 0, void 0, void 0, function* () {
+    const qstash = yield ensureQstash();
+    if (!qstash) {
         return null;
     }
-    cachedQstash = new Client({ token: QSTASH_TOKEN });
-    return cachedQstash;
-};
+    return fn(qstash);
+});
 
-export { getQstash, getRedis };
+export { getQstash, getRedis, withQstash, withRedis };