@windrun-huaiin/backend-core 13.0.0 → 14.1.0

package/src/lib/stripe-config.ts

@@ -1,10 +1,22 @@
 import Stripe from 'stripe';
 import { Apilogger, userService, subscriptionService } from '../services/database/index';
 
-// Stripe Configuration
-export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
-  apiVersion: '2025-11-17.clover',
-});
+let stripeInstance: Stripe | null = null;
+
+export const getStripe = (): Stripe => {
+  const apiKey = process.env.STRIPE_SECRET_KEY;
+  if (!apiKey) {
+    throw new Error('STRIPE_SECRET_KEY is not configured');
+  }
+
+  if (!stripeInstance) {
+    stripeInstance = new Stripe(apiKey, {
+      apiVersion: '2025-11-17.clover',
+    });
+  }
+
+  return stripeInstance;
+};
 
 // Helper function to validate webhook signature
 export const validateStripeWebhook = (
@@ -12,7 +24,7 @@ export const validateStripeWebhook = (
   signature: string,
   secret: string
 ): Stripe.Event => {
-  return stripe.webhooks.constructEvent(payload, signature, secret);
+  return getStripe().webhooks.constructEvent(payload, signature, secret);
 };
 
 export interface BasicCheckoutSessionParams {
@@ -95,7 +107,7 @@ export const createCheckoutSession = async (
   const logId = await Apilogger.logStripeOutgoing('createCheckoutSession', params);
 
   try {
-    const session = await stripe.checkout.sessions.create(sessionParams);
+    const session = await getStripe().checkout.sessions.create(sessionParams);
 
     // Update log record with response
     Apilogger.updateResponse(logId, {
@@ -116,7 +128,7 @@ export const createCheckoutSession = async (
 
 // 根据发票ID去查支付ID
 export const fetchPaymentId = async (invoiceId: string ): Promise<string> => {
-  const fullInvoice = await stripe.invoices.retrieve(invoiceId, {
+  const fullInvoice = await getStripe().invoices.retrieve(invoiceId, {
     expand: ['payments']
   });
   const payment = fullInvoice.payments?.data[0];
@@ -147,7 +159,7 @@ export const createOrGetCustomer = async (params: {
 
   if (user.stripeCusId) {
     try {
-      const customer = await stripe.customers.retrieve(user.stripeCusId);
+      const customer = await getStripe().customers.retrieve(user.stripeCusId);
       if ('deleted' in customer) {
         await setStripeCustomerId(null);
       } else {
@@ -164,7 +176,7 @@ export const createOrGetCustomer = async (params: {
   }
 
   if (user.email) {
-    const existingCustomers = await stripe.customers.list({
+    const existingCustomers = await getStripe().customers.list({
       email: user.email,
       limit: 1,
     });
@@ -201,7 +213,7 @@ export const createOrGetCustomer = async (params: {
   });
   
   try {
-    const customer = await stripe.customers.create(customerParams);
+    const customer = await getStripe().customers.create(customerParams);
     await setStripeCustomerId(customer.id);
     
     // Update log record with response
@@ -228,13 +240,13 @@ export const updateSubscription = async (params: {
 }): Promise<Stripe.Subscription> => {
   const { subscriptionId, priceId, prorationBehavior = 'create_prorations' } = params;
 
-  const subscription = await stripe.subscriptions.retrieve(subscriptionId);
+  const subscription = await getStripe().subscriptions.retrieve(subscriptionId);
   
   // Create log record with request
   const logId = await Apilogger.logStripeOutgoing('updateSubscription', params);
   
   try {
-    const updatedSubscription = await stripe.subscriptions.update(subscriptionId, {
+    const updatedSubscription = await getStripe().subscriptions.update(subscriptionId, {
       items: [
         {
           id: subscription.items.data[0].id,
@@ -267,7 +279,7 @@ export const createCustomerPortalSession = async (params: {
   const logId = await Apilogger.logStripeOutgoing('createCustomerPortalSession', params);
 
   try {
-    const session = await stripe.billingPortal.sessions.create({
+    const session = await getStripe().billingPortal.sessions.create({
       customer: params.customerId,
       return_url: params.returnUrl,
     });
@@ -301,11 +313,11 @@ export const cancelSubscription = async (
     let result: Stripe.Subscription;
     
     if (cancelAtPeriodEnd) {
-      result = await stripe.subscriptions.update(subscriptionId, {
+      result = await getStripe().subscriptions.update(subscriptionId, {
         cancel_at_period_end: true,
       });
     } else {
-      result = await stripe.subscriptions.cancel(subscriptionId);
+      result = await getStripe().subscriptions.cancel(subscriptionId);
     }
     
     // Update log record with response

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);
   }
 };