@windrun-huaiin/backend-core 13.0.0 → 14.0.0

package/src/lib/upstash/qstash.ts

@@ -1,8 +1,9 @@
 import { Receiver } from '@upstash/qstash';
-import { getQstash } from '../upstash-config';
+import { withQstash } from '../upstash-config';
 
 let cachedReceiver: Receiver | null = null;
-let receiverInitAttempted = false;
+let receiverWarnedMissingEnv = false;
+let receiverWarnedInitError = false;
 
 const isTruthy = (value: string | undefined): boolean =>
   value === '1' || value === 'true' || value === 'TRUE';
@@ -14,22 +15,33 @@ const getReceiver = (): Receiver | null => {
   if (cachedReceiver) {
     return cachedReceiver;
   }
-  if (receiverInitAttempted) {
-    return null;
-  }
-  receiverInitAttempted = true;
 
   const currentSigningKey = process.env.QSTASH_CURRENT_SIGNING_KEY;
   const nextSigningKey = process.env.QSTASH_NEXT_SIGNING_KEY;
   if (!currentSigningKey || !nextSigningKey) {
+    if (!receiverWarnedMissingEnv) {
+      receiverWarnedMissingEnv = true;
+      console.warn(
+        '[Upstash Config] QStash Receiver disabled: missing QSTASH_CURRENT_SIGNING_KEY or QSTASH_NEXT_SIGNING_KEY'
+      );
+    }
     return null;
   }
 
-  cachedReceiver = new Receiver({
-    currentSigningKey,
-    nextSigningKey,
-  });
-  return cachedReceiver;
+  try {
+    cachedReceiver = new Receiver({
+      currentSigningKey,
+      nextSigningKey,
+    });
+    return cachedReceiver;
+  } catch (error) {
+    if (!receiverWarnedInitError) {
+      receiverWarnedInitError = true;
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[Upstash Config] QStash Receiver init failed: ${message}`);
+    }
+    return null;
+  }
 };
 
 export type PublishBody = Record<string, unknown> | string | number | boolean | null;
@@ -43,16 +55,13 @@ export interface PublishMessageOptions {
  * Publish a message. Returns message id or null if QStash is unavailable.
  */
 export const publishMessage = async (options: PublishMessageOptions): Promise<string | null> => {
-  const client = getQstash();
-  if (!client) {
-    return null;
-  }
-
-  const result = await (client as any).publishJSON({
-    url: options.url,
-    body: options.body,
+  return withQstash(async (client) => {
+    const result = await (client as any).publishJSON({
+      url: options.url,
+      body: options.body,
+    });
+    return typeof result === 'string' ? result : result?.messageId ?? null;
   });
-  return typeof result === 'string' ? result : result?.messageId ?? null;
 };
 
 /**
@@ -61,17 +70,14 @@ export const publishMessage = async (options: PublishMessageOptions): Promise<st
 export const publishDelayedMessage = async (
   options: PublishMessageOptions & { delaySec: number }
 ): Promise<string | null> => {
-  const client = getQstash();
-  if (!client) {
-    return null;
-  }
-
-  const result = await (client as any).publishJSON({
-    url: options.url,
-    body: options.body,
-    delay: options.delaySec,
+  return withQstash(async (client) => {
+    const result = await (client as any).publishJSON({
+      url: options.url,
+      body: options.body,
+      delay: options.delaySec,
+    });
+    return typeof result === 'string' ? result : result?.messageId ?? null;
   });
-  return typeof result === 'string' ? result : result?.messageId ?? null;
 };
 
 export interface ScheduleMessageOptions extends PublishMessageOptions {
@@ -82,46 +88,42 @@ export interface ScheduleMessageOptions extends PublishMessageOptions {
  * Schedule a recurring message. Returns schedule id or null if QStash is unavailable.
  */
 export const scheduleMessage = async (options: ScheduleMessageOptions): Promise<string | null> => {
-  const client = getQstash();
-  if (!client) {
-    return null;
-  }
-
-  const anyClient = client as any;
-  const result =
-    (await anyClient.schedules?.create?.({
-      url: options.url,
-      body: options.body,
-      cron: options.cron,
-    })) ??
-    (await anyClient.publishJSON?.({
-      url: options.url,
-      body: options.body,
-      cron: options.cron,
-    }));
-
-  return typeof result === 'string' ? result : result?.scheduleId ?? result?.id ?? null;
+  return withQstash(async (client) => {
+    const anyClient = client as any;
+    const result =
+      (await anyClient.schedules?.create?.({
+        url: options.url,
+        body: options.body,
+        cron: options.cron,
+      })) ??
+      (await anyClient.publishJSON?.({
+        url: options.url,
+        body: options.body,
+        cron: options.cron,
+      }));
+
+    return typeof result === 'string' ? result : result?.scheduleId ?? result?.id ?? null;
+  });
 };
 
 /**
  * Cancel a scheduled message. Returns false if QStash is unavailable.
  */
 export const cancelSchedule = async (scheduleId: string): Promise<boolean> => {
-  const client = getQstash();
-  if (!client) {
+  const result = await withQstash(async (client) => {
+    const anyClient = client as any;
+    if (anyClient.schedules?.delete) {
+      await anyClient.schedules.delete(scheduleId);
+      return true;
+    }
+    if (anyClient.schedules?.remove) {
+      await anyClient.schedules.remove(scheduleId);
+      return true;
+    }
     return false;
-  }
+  });
 
-  const anyClient = client as any;
-  if (anyClient.schedules?.delete) {
-    await anyClient.schedules.delete(scheduleId);
-    return true;
-  }
-  if (anyClient.schedules?.remove) {
-    await anyClient.schedules.remove(scheduleId);
-    return true;
-  }
-  return false;
+  return result ?? false;
 };
 
 export interface VerifyQstashOptions {

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

@@ -1,51 +1,35 @@
-import { getRedis } from '../upstash-config';
+import { withRedis } from '../upstash-config';
 
 /**
  * Increment a counter (e.g. views, forwards). Returns null if Redis is unavailable.
  */
 export const incrCounter = async (key: string, delta = 1): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-  return redis.incrby(key, delta);
+  return withRedis((redis) => redis.incrby(key, delta));
 };
 
 /**
  * Get a counter value. Returns null if Redis is unavailable.
  */
 export const getCounter = async (key: string): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-  const value = await redis.get<number>(key);
-  return value ?? 0;
+  return withRedis(async (redis) => {
+    const value = await redis.get<number>(key);
+    return value ?? 0;
+  });
 };
 
 /**
  * Increment a unique counter via SET (e.g. unique views). Returns null if Redis is unavailable.
  */
 export const incrUniqueCounter = async (setKey: string, memberId: string): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const added = await redis.sadd(setKey, memberId);
-  if (added === 1) {
+  return withRedis(async (redis) => {
+    await redis.sadd(setKey, memberId);
     return redis.scard(setKey);
-  }
-  return redis.scard(setKey);
+  });
 };
 
 /**
  * Get unique counter value (SET cardinality). Returns null if Redis is unavailable.
  */
 export const getUniqueCounter = async (setKey: string): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-  return redis.scard(setKey);
+  return withRedis((redis) => redis.scard(setKey));
 };

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

@@ -1,4 +1,4 @@
-import { getRedis } from '../upstash-config';
+import { withRedis } from '../upstash-config';
 
 const favoriteTargetKey = (targetId: string): string => `favorite:target:${targetId}`;
 const favoriteUserKey = (userId: string): string => `favorite:user:${userId}`;
@@ -7,69 +7,50 @@ const favoriteUserKey = (userId: string): string => `favorite:user:${userId}`;
  * Favorite a target. Returns true if added, false if already favorited, null if Redis is unavailable.
  */
 export const addFavorite = async (targetId: string, userId: string): Promise<boolean | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const added = await redis.sadd(favoriteTargetKey(targetId), userId);
-  if (added === 1) {
-    await redis.sadd(favoriteUserKey(userId), targetId);
-    return true;
-  }
-  return false;
+  return withRedis(async (redis) => {
+    const added = await redis.sadd(favoriteTargetKey(targetId), userId);
+    if (added === 1) {
+      await redis.sadd(favoriteUserKey(userId), targetId);
+      return true;
+    }
+    return false;
+  });
 };
 
 /**
  * Remove a favorite. Returns true if removed, false if not found, null if Redis is unavailable.
  */
 export const removeFavorite = async (targetId: string, userId: string): Promise<boolean | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const removed = await redis.srem(favoriteTargetKey(targetId), userId);
-  if (removed === 1) {
-    await redis.srem(favoriteUserKey(userId), targetId);
-    return true;
-  }
-  return false;
+  return withRedis(async (redis) => {
+    const removed = await redis.srem(favoriteTargetKey(targetId), userId);
+    if (removed === 1) {
+      await redis.srem(favoriteUserKey(userId), targetId);
+      return true;
+    }
+    return false;
+  });
 };
 
 /**
  * Check whether a user has favorited a target. Returns null if Redis is unavailable.
  */
 export const isFavorited = async (targetId: string, userId: string): Promise<boolean | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const result = await redis.sismember(favoriteTargetKey(targetId), userId);
-  return result === 1;
+  return withRedis(async (redis) => {
+    const result = await redis.sismember(favoriteTargetKey(targetId), userId);
+    return result === 1;
+  });
 };
 
 /**
  * Get favorite count for a target. Returns null if Redis is unavailable.
  */
 export const getFavoriteCount = async (targetId: string): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.scard(favoriteTargetKey(targetId));
+  return withRedis((redis) => redis.scard(favoriteTargetKey(targetId)));
 };
 
 /**
  * Get target ids favorited by a user. Returns null if Redis is unavailable.
  */
 export const getUserFavorites = async (userId: string): Promise<string[] | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.smembers<string[]>(favoriteUserKey(userId));
+  return withRedis((redis) => redis.smembers<string[]>(favoriteUserKey(userId)));
 };

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

@@ -1,4 +1,4 @@
-import { getRedis } from '../upstash-config';
+import { withRedis } from '../upstash-config';
 
 const likeTargetKey = (targetId: string): string => `like:target:${targetId}`;
 const likeUserKey = (userId: string): string => `like:user:${userId}`;
@@ -7,69 +7,50 @@ const likeUserKey = (userId: string): string => `like:user:${userId}`;
  * Like a target. Returns true if the like was added, false if it already existed, null if Redis is unavailable.
  */
 export const likeTarget = async (targetId: string, userId: string): Promise<boolean | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const added = await redis.sadd(likeTargetKey(targetId), userId);
-  if (added === 1) {
-    await redis.sadd(likeUserKey(userId), targetId);
-    return true;
-  }
-  return false;
+  return withRedis(async (redis) => {
+    const added = await redis.sadd(likeTargetKey(targetId), userId);
+    if (added === 1) {
+      await redis.sadd(likeUserKey(userId), targetId);
+      return true;
+    }
+    return false;
+  });
 };
 
 /**
  * Unlike a target. Returns true if removed, false if it didn't exist, null if Redis is unavailable.
  */
 export const unlikeTarget = async (targetId: string, userId: string): Promise<boolean | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const removed = await redis.srem(likeTargetKey(targetId), userId);
-  if (removed === 1) {
-    await redis.srem(likeUserKey(userId), targetId);
-    return true;
-  }
-  return false;
+  return withRedis(async (redis) => {
+    const removed = await redis.srem(likeTargetKey(targetId), userId);
+    if (removed === 1) {
+      await redis.srem(likeUserKey(userId), targetId);
+      return true;
+    }
+    return false;
+  });
 };
 
 /**
  * Check whether a user liked a target. Returns null if Redis is unavailable.
  */
 export const isTargetLiked = async (targetId: string, userId: string): Promise<boolean | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  const result = await redis.sismember(likeTargetKey(targetId), userId);
-  return result === 1;
+  return withRedis(async (redis) => {
+    const result = await redis.sismember(likeTargetKey(targetId), userId);
+    return result === 1;
+  });
 };
 
 /**
  * Get like count for a target (unique by user). Returns null if Redis is unavailable.
  */
 export const getTargetLikeCount = async (targetId: string): Promise<number | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.scard(likeTargetKey(targetId));
+  return withRedis((redis) => redis.scard(likeTargetKey(targetId)));
 };
 
 /**
  * Get target ids liked by a user. Returns null if Redis is unavailable.
  */
 export const getUserLikedTargets = async (userId: string): Promise<string[] | null> => {
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  return redis.smembers<string[]>(likeUserKey(userId));
+  return withRedis((redis) => redis.smembers<string[]>(likeUserKey(userId)));
 };

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

@@ -1,62 +1,41 @@
-import { Lock } from '@upstash/lock';
-import type { Redis } from '@upstash/redis';
-import { getRedis } from '../upstash-config';
+import { withRedis } from '../upstash-config';
 
-type UpstashLock = {
-  acquire: (key: string, ttlMs: number) => Promise<string | null>;
-  release: (key: string, token: string) => Promise<boolean>;
-};
-
-let cachedLock: UpstashLock | null = null;
-let lockInitAttempted = false;
+const unlockScript = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("del", KEYS[1])
+else
+  return 0
+end
+`;
 
-const createLock = (redis: Redis): UpstashLock => {
-  const LockCtor = Lock as unknown as new (...args: any[]) => UpstashLock;
+const generateToken = (): string => {
   try {
-    return new LockCtor({ redis });
+    return crypto.randomUUID();
   } catch {
-    return new LockCtor(redis);
+    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
   }
 };
 
-const getLock = (): UpstashLock | null => {
-  if (cachedLock) {
-    return cachedLock;
-  }
-  if (lockInitAttempted) {
-    return null;
-  }
-  lockInitAttempted = true;
-
-  const redis = getRedis();
-  if (!redis) {
-    return null;
-  }
-
-  cachedLock = createLock(redis);
-  return cachedLock;
-};
-
 /**
  * Acquire a distributed lock. Returns the lock token or null when unavailable.
  */
 export const acquireLock = async (key: string, ttlMs: number): Promise<string | null> => {
-  const lock = getLock();
-  if (!lock) {
-    return null;
-  }
-  return lock.acquire(key, ttlMs);
+  return withRedis(async (redis) => {
+    const token = generateToken();
+    const result = await redis.set(key, token, { nx: true, px: ttlMs });
+    return result === 'OK' ? token : null;
+  });
 };
 
 /**
  * Release a distributed lock. Returns false when the lock client is unavailable.
  */
 export const releaseLock = async (key: string, token: string): Promise<boolean> => {
-  const lock = getLock();
-  if (!lock) {
-    return false;
-  }
-  return lock.release(key, token);
+  const result = await withRedis(async (redis) => {
+    const released = await redis.eval(unlockScript, [key], [token]);
+    return Number(released) === 1;
+  });
+  return result ?? false;
 };
 
 /**
@@ -67,12 +46,7 @@ export const withLock = async <T>(
   ttlMs: number,
   fn: () => Promise<T> | T
 ): Promise<T | null> => {
-  const lock = getLock();
-  if (!lock) {
-    return null;
-  }
-
-  const token = await lock.acquire(key, ttlMs);
+  const token = await acquireLock(key, ttlMs);
   if (!token) {
     return null;
   }
@@ -80,6 +54,6 @@ export const withLock = async <T>(
   try {
     return await fn();
   } finally {
-    await lock.release(key, token);
+    await releaseLock(key, token);
   }
 };