Merge pull request #431 from SageSeekerSociety/dev

chore(release): 0.12.1

Author: HuanCheng65

package.json

@@ -94,6 +94,7 @@
     "eslint-plugin-prettier": "^5.2.3",
     "husky": "^9.1.7",
     "jest": "^29.7.0",
+    "jest-mock-extended": "4.0.0-beta1",
     "lint-staged": "^15.2.11",
     "prettier": "^3.5.1",
     "prisma": "^5.22.0",

pnpm-lock.yaml

@@ -1,9 +1,24 @@
 import { ConfigService } from '@nestjs/config';
 import { ElasticsearchModuleOptions } from '@nestjs/elasticsearch';
 
+export interface RedisConfig {
+  host: string;
+  port: number;
+  username?: string;
+  password?: string;
+  db?: number;
+}
+
 export default () => {
   return {
     port: parseInt(process.env.PORT || '3000', 10),
+    redis: {
+      host: process.env.REDIS_HOST || 'localhost',
+      port: parseInt(process.env.REDIS_PORT || '6379', 10),
+      username: process.env.REDIS_USERNAME || undefined,
+      password: process.env.REDIS_PASSWORD || undefined,
+      db: process.env.REDIS_DB ? parseInt(process.env.REDIS_DB, 10) : undefined,
+    },
     elasticsearch: {
       node: process.env.ELASTICSEARCH_NODE,
       maxRetries: parseInt(process.env.ELASTICSEARCH_MAX_RETRIES || '3', 10),
@@ -42,7 +57,7 @@ export default () => {
         process.env.TOTP_BACKUP_CODES_COUNT || '10',
         10,
       ),
-      window: parseInt(process.env.TOTP_WINDOW || '1', 10), // 验证窗口，默认前后1个时间窗口
+      window: parseInt(process.env.TOTP_WINDOW || '1', 10),
     },
     disableEmailVerification: process.env.DISABLE_EMAIL_VERIFICATION === 'true',
   };
@@ -56,3 +71,9 @@ export function elasticsearchConfigFactory(
     throw new Error('Elasticsearch configuration not found');
   return config;
 }
+
+export function redisConfigFactory(configService: ConfigService): RedisConfig {
+  const config = configService.get<RedisConfig>('redis');
+  if (config == undefined) throw new Error('Redis configuration not found');
+  return config;
+}

src/common/config/configuration.ts

@@ -2,9 +2,12 @@ import crypto from 'crypto';
 import * as fs from 'fs';
 import mime from 'mime-types';
 
-export function getFileHash(filePath: string): Promise<string> {
+export function getFileHash(
+  filePath: string,
+  algorithm: 'sha256' | 'md5' = 'sha256',
+): Promise<string> {
   return new Promise((resolve, reject) => {
-    const hash = crypto.createHash('sha256');
+    const hash = crypto.createHash(algorithm);
     const stream = fs.createReadStream(filePath);
     stream
       .on('data', (data) => {

src/common/helper/file.helper.ts

@@ -11,13 +11,12 @@ import { Injectable, OnModuleInit } from '@nestjs/common';
 import { MaterialType } from '@prisma/client';
 import ffmpeg from 'fluent-ffmpeg';
 import path, { join } from 'node:path';
-import { readFileSync } from 'node:fs';
 import { promisify } from 'node:util';
+import { getFileHash } from '../common/helper/file.helper';
 import { PrismaService } from '../common/prisma/prisma.service';
-import { MaterialNotFoundError, MetaDataParseError } from './materials.error';
-import { materialDto } from './DTO/material.dto';
 import { UsersService } from '../users/users.service';
-import md5 from 'md5';
+import { materialDto } from './DTO/material.dto';
+import { MaterialNotFoundError, MetaDataParseError } from './materials.error';
 @Injectable()
 export class MaterialsService implements OnModuleInit {
   private ffprobeAsync: (file: string) => Promise<ffmpeg.FfprobeData>;
@@ -101,8 +100,7 @@ export class MaterialsService implements OnModuleInit {
   ): Promise<PrismaJson.metaType> {
     let meta: PrismaJson.metaType;
 
-    const buf = readFileSync(file.path);
-    const hash = md5(buf);
+    const hash = await getFileHash(file.path, 'md5');
 
     if (type === MaterialType.image) {
       const metadata = await this.getImageMetadata(file.path);

src/materials/materials.service.ts

@@ -7,6 +7,7 @@
  *
  */
 
+import { RedisService } from '@liaoliaots/nestjs-redis';
 import { Inject, Injectable, Logger, forwardRef } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import {
@@ -30,6 +31,7 @@ import {
 import bcrypt from 'bcryptjs';
 import { isEmail } from 'class-validator';
 import { Request } from 'express';
+import Redis from 'ioredis';
 import assert from 'node:assert';
 import { AnswerService } from '../answer/answer.service';
 import {
@@ -81,9 +83,15 @@ import {
   UsernameNotFoundError,
 } from './users.error';
 
+const USER_PROFILE_UPDATE_CHANNEL = 'cache:user:updated';
+
 @Injectable()
 export class UsersService {
+  private readonly logger = new Logger(UsersService.name);
+  private readonly redis: Redis;
+
   constructor(
+    private readonly redisService: RedisService,
     private readonly emailService: EmailService,
     private readonly emailRuleService: EmailRuleService,
     private readonly authService: AuthService,
@@ -100,7 +108,9 @@ export class UsersService {
     private readonly prismaService: PrismaService,
     private readonly totpService: TOTPService,
     private readonly srpService: SrpService,
-  ) {}
+  ) {
+    this.redis = this.redisService.getOrThrow();
+  }
 
   private readonly passwordResetEmailValidSeconds = 10 * 60; // 10 minutes
 
@@ -1039,23 +1049,70 @@ export class UsersService {
     intro: string,
     avatarId: number,
   ): Promise<void> {
+    this.logger.log(`Attempting to update profile for user ID: ${userId}`);
     const [, profile] =
       await this.findUserRecordAndProfileRecordOrThrow(userId);
-    if ((await this.avatarsService.isAvatarExists(avatarId)) == false) {
+
+    if ((await this.avatarsService.isAvatarExists(avatarId)) === false) {
+      this.logger.warn(`Avatar not found: ${avatarId} for user: ${userId}`);
       throw new AvatarNotFoundError(avatarId);
     }
-    await this.avatarsService.plusUsageCount(avatarId);
-    await this.avatarsService.minusUsageCount(profile.avatarId);
-    await this.prismaService.userProfile.update({
-      where: {
-        userId,
-      },
-      data: {
-        nickname,
-        intro,
-        avatarId,
-      },
-    });
+
+    const oldAvatarId = profile.avatarId;
+
+    if (
+      profile.nickname !== nickname ||
+      profile.intro !== intro ||
+      profile.avatarId !== avatarId
+    ) {
+      await this.prismaService.userProfile.update({
+        where: {
+          userId,
+        },
+        data: {
+          nickname,
+          intro,
+          avatarId,
+        },
+      });
+      this.logger.log(`Profile successfully updated for user ID: ${userId}`);
+
+      try {
+        const publishedCount = await this.redis.publish(
+          USER_PROFILE_UPDATE_CHANNEL,
+          userId.toString(),
+        );
+        this.logger.log(
+          `Published cache invalidation message for user ID: ${userId} to channel '${USER_PROFILE_UPDATE_CHANNEL}'. Received by ${publishedCount} clients.`,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to publish cache invalidation message for user ID: ${userId} to Redis channel '${USER_PROFILE_UPDATE_CHANNEL}'`,
+          error instanceof Error ? error.stack : error,
+        );
+      }
+
+      if (oldAvatarId !== avatarId) {
+        try {
+          await Promise.all([
+            this.avatarsService.plusUsageCount(avatarId),
+            this.avatarsService.minusUsageCount(oldAvatarId),
+          ]);
+          this.logger.log(
+            `Updated avatar usage counts for user ID: ${userId}. New: ${avatarId}, Old: ${oldAvatarId}`,
+          );
+        } catch (avatarError) {
+          this.logger.error(
+            `Error updating avatar usage counts for user ID ${userId}`,
+            avatarError instanceof Error ? avatarError.stack : avatarError,
+          );
+        }
+      }
+    } else {
+      this.logger.log(
+        `Profile data unchanged for user ID: ${userId}. Skipping update and cache invalidation.`,
+      );
+    }
   }
 
   async getUniqueFollowRelationship(