@windrun-huaiin/backend-core 10.0.1

package/src/services/context/user-context-service.ts

@@ -0,0 +1,200 @@
+import { creditService, subscriptionService, userService } from '../database/index';
+import type { Credit, Subscription, User } from '../database/prisma-model-type';
+import { viewLocalTime } from '@windrun-huaiin/lib/utils';
+import type { XCredit, XSubscription, XUser } from '@windrun-huaiin/third-ui/fingerprint';
+import type { InitUserContext } from '@windrun-huaiin/third-ui/main/server';
+
+export interface UserContextEntities {
+  user: User;
+  credit: Credit | null;
+  subscription: Subscription | null;
+}
+
+export interface FingerprintUserContext extends UserContextEntities {
+  totalUsersOnDevice: number;
+  hasAnonymousUser: boolean;
+}
+
+export function mapUserToXUser(user: User): XUser {
+  return {
+    userId: user.userId,
+    userName: user.userName || '',
+    fingerprintId: user.fingerprintId || '',
+    clerkUserId: user.clerkUserId || '',
+    stripeCusId: user.stripeCusId || '',
+    email: user.email || '',
+    status: user.status,
+    createdAt: viewLocalTime(user.createdAt),
+  };
+}
+
+export function mapCreditToXCredit(credit: Credit): XCredit {
+  return {
+    balanceFree: credit.balanceFree,
+    totalFreeLimit: credit.totalFreeLimit,
+    freeStart: viewLocalTime(credit.freeStart),
+    freeEnd: viewLocalTime(credit.freeEnd),
+    balancePaid: credit.balancePaid,
+    totalPaidLimit: credit.totalPaidLimit,
+    paidStart: viewLocalTime(credit.paidStart),
+    paidEnd: viewLocalTime(credit.paidEnd),
+    balanceOneTimePaid: credit.balanceOneTimePaid,
+    totalOneTimePaidLimit: credit.totalOneTimePaidLimit,
+    oneTimePaidStart: viewLocalTime(credit.oneTimePaidStart),
+    oneTimePaidEnd: viewLocalTime(credit.oneTimePaidEnd),
+    totalBalance: credit.balanceFree + credit.balancePaid + credit.balanceOneTimePaid,
+  };
+}
+
+export function mapSubscriptionToXSubscription(
+  subscription: Subscription | null,
+): XSubscription | null {
+  if (!subscription) {
+    return null;
+  }
+
+  return {
+    id: subscription.id,
+    userId: subscription.userId || '',
+    paySubscriptionId: subscription.paySubscriptionId || '',
+    orderId: subscription.orderId || '',
+    priceId: subscription.priceId || '',
+    priceName: subscription.priceName || '',
+    status: subscription.status || '',
+    creditsAllocated: subscription.creditsAllocated,
+    subPeriodStart: viewLocalTime(subscription.subPeriodStart),
+    subPeriodEnd: viewLocalTime(subscription.subPeriodEnd),
+  };
+}
+
+export function buildInitUserContextFromEntities(params: {
+  user: User;
+  credit: Credit | null;
+  subscription: Subscription | null;
+  isClerkAuthenticated?: boolean;
+}): InitUserContext {
+  return {
+    fingerprintId: params.user.fingerprintId || null,
+    xUser: mapUserToXUser(params.user),
+    xCredit: params.credit ? mapCreditToXCredit(params.credit) : null,
+    xSubscription: mapSubscriptionToXSubscription(params.subscription),
+    isClerkAuthenticated: params.isClerkAuthenticated ?? true,
+  };
+}
+
+export async function fetchUserContextByClerkUserId(
+  clerkUserId: string,
+): Promise<UserContextEntities | null> {
+  const user = await userService.findByClerkUserId(clerkUserId);
+
+  if (!user) {
+    return null;
+  }
+
+  const [credit, subscription] = await Promise.all([
+    creditService.getCredit(user.userId),
+    subscriptionService.getActiveSubscription(user.userId),
+  ]);
+
+  return { user, credit, subscription };
+}
+
+export async function fetchLatestUserContextByFingerprintId(
+  fingerprintId: string,
+): Promise<FingerprintUserContext | null> {
+  const existingUsers = await userService.findListByFingerprintId(fingerprintId);
+  if (existingUsers.length === 0) {
+    return null;
+  }
+
+  const latestAnonymousUser = existingUsers[0];
+  const [credit, subscription] = await Promise.all([
+    creditService.getCredit(latestAnonymousUser.userId),
+    subscriptionService.getActiveSubscription(latestAnonymousUser.userId),
+  ]);
+
+  return {
+    user: latestAnonymousUser,
+    credit,
+    subscription,
+    totalUsersOnDevice: existingUsers.length,
+    hasAnonymousUser: true,
+  };
+}
+
+type MockableContext = {
+  xUser: XUser | null;
+  xSubscription: XSubscription | null;
+};
+
+export function applyUserMockContext<T extends MockableContext>(context: T): T {
+  const mockEnabled = process.env.MONEY_PRICE_MOCK_USER_ENABLED === 'true';
+  const mockType = Number(process.env.MONEY_PRICE_MOCK_USER_TYPE ?? NaN);
+
+  if (
+    !context.xUser ||
+    !mockEnabled ||
+    !Number.isInteger(mockType) ||
+    mockType < 0 ||
+    mockType > 4
+  ) {
+    return context;
+  }
+
+  const ensureSubscription = () => {
+    if (!context.xSubscription) {
+      const now = new Date();
+      context.xSubscription = {
+        id: BigInt(99999),
+        userId: context.xUser!.userId,
+        paySubscriptionId: 'MOCK-PAY-SUB-ID',
+        orderId: '',
+        priceId: '',
+        priceName: 'MOCK-TEST',
+        status: 'active',
+        creditsAllocated: 0,
+        subPeriodStart: viewLocalTime(now),
+        subPeriodEnd: viewLocalTime(now),
+      };
+    }
+
+    return context.xSubscription!;
+  };
+
+  switch (mockType) {
+    case 0: {
+      const subscription = ensureSubscription();
+      subscription.status = '';
+      subscription.priceId = '';
+      break;
+    }
+    case 1: {
+      const subscription = ensureSubscription();
+      subscription.priceId =
+        process.env.STRIPE_PRO_MONTHLY_PRICE_ID || subscription.priceId;
+      break;
+    }
+    case 2: {
+      const subscription = ensureSubscription();
+      subscription.priceId =
+        process.env.STRIPE_ULTRA_MONTHLY_PRICE_ID || subscription.priceId;
+      break;
+    }
+    case 3: {
+      const subscription = ensureSubscription();
+      subscription.priceId =
+        process.env.STRIPE_PRO_YEARLY_PRICE_ID || subscription.priceId;
+      break;
+    }
+    case 4: {
+      const subscription = ensureSubscription();
+      subscription.priceId =
+        process.env.STRIPE_ULTRA_YEARLY_PRICE_ID || subscription.priceId;
+      break;
+    }
+    default:
+      break;
+  }
+
+  return context;
+}

package/src/services/database/apilog.service.ts

@@ -0,0 +1,185 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type { Prisma } from './prisma-model-type';
+import type { Apilog } from './prisma-model-type';
+import { checkAndFallbackWithNonTCClient } from '../../prisma/index';
+
+export type ApiType = 'from_clerk_in' | 'to_clerk_out' | 'from_stripe_in' | 'to_stripe_out';
+
+export interface CreateApiLogData {
+  methodName: string;
+  request?: any;
+  summary?: any;
+  apiType: ApiType;
+}
+
+export class ApilogService {
+
+  // Create API log record with request
+  async createApilog(data: CreateApiLogData, tx?: Prisma.TransactionClient): Promise<string> {
+    const client = checkAndFallbackWithNonTCClient(tx);
+    const log = await client.apilog.create({
+      data: {
+        methodName: data.methodName,
+        request: data.request ? JSON.stringify(data.request) : null,
+        summary: data.summary ? JSON.stringify(data.summary) : null,
+        apiType: data.apiType,
+      },
+    });
+    return log.id.toString();
+  }
+
+  // Update API log record with response
+  async updateApilogResponse(logId: string, response: any, tx?: Prisma.TransactionClient): Promise<void> {
+    const client = checkAndFallbackWithNonTCClient(tx);
+    await client.apilog.update({
+      where: { id: BigInt(logId) },
+      data: {
+        response: response ? JSON.stringify(response) : null,
+      },
+    });
+  }
+
+  // Get API log by ID
+  async getApilog(logId: string, tx?: Prisma.TransactionClient): Promise<Apilog | null> {
+    const client = checkAndFallbackWithNonTCClient(tx);
+    return await client.apilog.findUnique({
+      where: { id: BigInt(logId) },
+    });
+  }
+
+  // Get API logs with filters
+  async getApilogList(params: {
+    apiType?: ApiType;
+    methodName?: string;
+    limit?: number;
+    offset?: number;
+  }, tx?: Prisma.TransactionClient): Promise<Apilog[]> {
+    const { apiType, methodName, limit = 50, offset = 0 } = params;
+
+    const client = checkAndFallbackWithNonTCClient(tx);
+
+    return await client.apilog.findMany({
+      where: {
+        ...(apiType && { apiType }),
+        ...(methodName && { methodName: { contains: methodName } }),
+      },
+      orderBy: { createdAt: 'desc' },
+      take: limit,
+      skip: offset,
+    });
+  }
+
+  // Delete old API logs (cleanup)
+  async deleteOldLogList(daysOld: number = 30, tx?: Prisma.TransactionClient): Promise<number> {
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+
+    const client = checkAndFallbackWithNonTCClient(tx);
+    const result = await client.apilog.deleteMany({
+      where: {
+        createdAt: {
+          lt: cutoffDate,
+        },
+      },
+    });
+
+    return result.count;
+  }
+
+  // Get API log statistics
+  async getApilogStats(tx?: Prisma.TransactionClient): Promise<{
+    totalLogs: number;
+    clerkIncoming: number;
+    clerkOutgoing: number;
+    stripeIncoming: number;
+    stripeOutgoing: number;
+  }> {
+    const client = checkAndFallbackWithNonTCClient(tx);
+    const [total, clerkIn, clerkOut, stripeIn, stripeOut] = await Promise.all([
+      client.apilog.count(),
+      client.apilog.count({ where: { apiType: 'from_clerk_in' } }),
+      client.apilog.count({ where: { apiType: 'to_clerk_out' } }),
+      client.apilog.count({ where: { apiType: 'from_stripe_in' } }),
+      client.apilog.count({ where: { apiType: 'to_stripe_out' } }),
+    ]);
+
+    return {
+      totalLogs: total,
+      clerkIncoming: clerkIn,
+      clerkOutgoing: clerkOut,
+      stripeIncoming: stripeIn,
+      stripeOutgoing: stripeOut,
+    };
+  }
+}
+
+// API Logger Helper Class for convenience
+export class Apilogger {
+  static async createLogAsync(data: CreateApiLogData): Promise<string | null> {
+    try {
+      return await apilogService.createApilog(data);
+    } catch (error) {
+      console.error('Failed to create API log:', error);
+      return null;
+    }
+  }
+
+  static async updateResponseAsync(logId: string, response: any): Promise<void> {
+    try {
+      setImmediate(async () => {
+        try {
+          await apilogService.updateApilogResponse(logId, response);
+        } catch (error) {
+          console.error('Failed to update API log response:', error);
+        }
+      });
+    } catch (error) {
+      console.error('Failed to queue API log update:', error);
+    }
+  }
+
+  static async logClerkIncoming(methodName: string, summary?: any, originalRequest?: any): Promise<string | null> {
+    return await this.createLogAsync({
+      methodName,
+      request: originalRequest,
+      summary,
+      apiType: 'from_clerk_in',
+    });
+  }
+
+  static async logClerkOutgoing(methodName: string, request?: any, summary?: any): Promise<string | null> {
+    return await this.createLogAsync({
+      methodName,
+      request,
+      summary,
+      apiType: 'to_clerk_out',
+    });
+  }
+
+  static async logStripeIncoming(methodName: string, summary?: any, originalRequest?: any): Promise<string | null> {
+    return await this.createLogAsync({
+      methodName,
+      request: originalRequest,
+      summary,
+      apiType: 'from_stripe_in',
+    });
+  }
+
+  static async logStripeOutgoing(methodName: string, request?: any, summary?: any): Promise<string | null> {
+    return await this.createLogAsync({
+      methodName,
+      request,
+      summary,
+      apiType: 'to_stripe_out',
+    });
+  }
+
+  static updateResponse(logId: string | null, response: any): void {
+    if (logId) {
+      this.updateResponseAsync(logId, response);
+    }
+  }
+}
+
+export const apilogService = new ApilogService();

package/src/services/database/constants.ts

@@ -0,0 +1,148 @@
+// Database Field Enums
+// Keep in sync with DB CHECK constraints
+
+export const UserStatus = {
+  // 匿名用户
+  ANONYMOUS: 'anonymous',
+  // 注册用户
+  REGISTERED: 'registered',
+  // 管理员介入管控
+  FROZEN: 'frozen',
+  // 用户注销，数据软删除，用户数据将不可复用
+  DELETED: 'deleted',
+} as const;
+
+export const SubscriptionStatus = {
+  // 初始状态或注销后状态
+  INCOMPLETE: 'incomplete',
+  // 订阅试用期
+  TRIALING: 'trialing',
+  // 有效订阅激活
+  ACTIVE: 'active',
+  // 订阅过期
+  PAST_DUE: 'past_due',
+  // 取消订阅
+  CANCELED: 'canceled',
+} as const;
+
+export const OrderStatus = {
+  // 初始状态
+  CREATED: 'created',
+  // 中间状态，待支付，可能是支付失败事件触发
+  PENDING_UNPAID: 'pending_unpaid',
+  // 中间状态(也可是最终状态)，支付成功，后续可变为「退款或取消」
+  SUCCESS: 'success',
+  // 中间状态(也可是最终状态)，CheckOut失败或者是支付失败，后续可变为「退款或取消」
+  FAILED: 'failed',
+  // 最终状态，已退款
+  REFUNDED: 'refunded',
+  // 最终状态，已取消
+  CANCELED: 'canceled',
+} as const;
+
+export const TransactionType = {
+  // 订阅订单
+  SUBSCRIPTION: 'subscription',
+  // 即付订单
+  ONE_TIME: 'one_time',
+} as const;
+
+export const CreditType = {
+  // 订阅积分
+  PAID: 'paid',
+  // 即付积分
+  ONE_TIME_PAID: 'one_time_paid',
+  // 免费积分
+  FREE: 'free',
+} as const;
+
+export const OperationType = {
+  // 系统奖励积分
+  SYS_GIFT: 'system_gift',
+  // 用户消费积分
+  CONSUME: 'consume',
+  // 用户充值积分
+  RECHARGE: 'recharge',
+  // 管理员介入冻结积分
+  FREEZE: 'freeze',
+  // 管理员介入解冻积分
+  UNFREEZE: 'unfreeze',
+  // 管理员介入赠送积分
+  ADJUST_INCREASE: 'adjust_increase',
+  // 管理员介入抹去积分
+  ADJUST_DECREASE: 'adjust_decrease',
+  // 清理积分，事件触发或者是积分过期触发
+  PURGE: 'purge',
+} as const;
+
+// 支付厂商类型
+export const PaySupplier = {
+  STRIPE: 'Stripe',
+  APPLE: 'Apple',
+  PAYPAL: 'Paypal',
+} as const;
+
+export const BillingReason = {
+  // 首次订阅
+  SUBSCRIPTION_CREATE: 'subscription_create',
+  // 续订
+  SUBSCRIPTION_CYCLE: 'subscription_cycle',
+} as const;
+
+export const PaymentStatus = {
+  // 已支付
+  PAID: 'paid',
+  // 待支付
+  UN_PAID: 'un_paid',
+  // 无需支付
+  NO_PAYMENT_REQUIRED: 'no_payment_required',
+} as const;
+
+
+// Type Definitions
+export type UserStatus = typeof UserStatus[keyof typeof UserStatus];
+export type SubscriptionStatus = typeof SubscriptionStatus[keyof typeof SubscriptionStatus];
+export type OrderStatus = typeof OrderStatus[keyof typeof OrderStatus];
+export type TransactionType = typeof TransactionType[keyof typeof TransactionType];
+export type CreditType = typeof CreditType[keyof typeof CreditType];
+export type OperationType = typeof OperationType[keyof typeof OperationType];
+export type PaySupplier = typeof PaySupplier[keyof typeof PaySupplier];
+export type BillingReason = typeof BillingReason[keyof typeof BillingReason];
+export type PaymentStatus = typeof PaymentStatus[keyof typeof PaymentStatus];
+
+// Validation Functions
+export const isValidUserStatus = (status: string): status is UserStatus => {
+  return Object.values(UserStatus).includes(status as UserStatus);
+};
+
+export const isValidSubscriptionStatus = (status: string): status is SubscriptionStatus => {
+  return Object.values(SubscriptionStatus).includes(status as SubscriptionStatus);
+};
+
+export const isValidOrderStatus = (status: string): status is OrderStatus => {
+  return Object.values(OrderStatus).includes(status as OrderStatus);
+};
+
+export const isValidTransactionType = (type: string): type is TransactionType => {
+  return Object.values(TransactionType).includes(type as TransactionType);
+};
+
+export const isValidCreditType = (type: string): type is CreditType => {
+  return Object.values(CreditType).includes(type as CreditType);
+};
+
+export const isValidOperationType = (type: string): type is OperationType => {
+  return Object.values(OperationType).includes(type as OperationType);
+};
+
+export const isValidPaySupplier = (supplier: string): supplier is PaySupplier => {
+  return Object.values(PaySupplier).includes(supplier as PaySupplier);
+};
+
+export const isValidBillingReason = (reason: string): reason is BillingReason => {
+  return Object.values(BillingReason).includes(reason as BillingReason);
+};
+
+export const isValidPaymentStatus = (status: string): status is PaymentStatus => {
+  return Object.values(PaymentStatus).includes(status as PaymentStatus);
+};