create-pardx-scaffold 0.1.0

package/template/apps/api/libs/domain/db/src/modules/file-source/file-source.service.ts

@@ -0,0 +1,109 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '@app/prisma';
+import { TransactionalServiceBase } from '@app/shared-db';
+import { HandlePrismaError, DbOperationType } from '@/utils/prisma-error.util';
+import { AppConfig } from '@/config/validation';
+import type { Prisma, FileSource } from '@prisma/client';
+
+@Injectable()
+export class FileSourceService extends TransactionalServiceBase {
+  private appConfig: AppConfig;
+
+  constructor(
+    prisma: PrismaService,
+    private readonly config: ConfigService,
+  ) {
+    super(prisma);
+    this.appConfig = config.getOrThrow<AppConfig>('app');
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async get(
+    where: Prisma.FileSourceWhereInput,
+    additional?: { select?: Prisma.FileSourceSelect },
+  ): Promise<FileSource | null> {
+    return this.getReadClient().fileSource.findFirst({
+      where: { ...where, isDeleted: false },
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getById(
+    id: string,
+    additional?: { select?: Prisma.FileSourceSelect },
+  ): Promise<FileSource | null> {
+    return this.getReadClient().fileSource.findUnique({
+      where: { id: id, isDeleted: false },
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getByKey(value: string, additional?: { select?: Prisma.FileSourceSelect }): Promise<FileSource | null> {
+    return this.getReadClient().fileSource.findUnique({
+      where: { key: value, isDeleted: false },
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async list(
+    where: Prisma.FileSourceWhereInput,
+    pagination?: {
+      orderBy?: Prisma.FileSourceOrderByWithRelationInput;
+      limit?: number;
+      page?: number;
+    },
+    additional?: { select?: Prisma.FileSourceSelect },
+  ): Promise<{ list: FileSource[]; total: number; page: number; limit: number }> {
+    const {
+      orderBy = { createdAt: 'desc' },
+      limit = this.appConfig.MaxPageSize,
+      page = 1,
+    } = pagination || {};
+    const skip = (page - 1) * limit;
+
+    const [list, total] = await Promise.all([
+      this.getReadClient().fileSource.findMany({
+        where: { ...where, isDeleted: false },
+        orderBy,
+        take: limit,
+        skip,
+        ...additional,
+      }),
+      this.getReadClient().fileSource.count({
+        where: { ...where, isDeleted: false },
+      }),
+    ]);
+
+    return { list, total, page, limit };
+  }
+
+  @HandlePrismaError(DbOperationType.CREATE)
+  async create(
+    data: Prisma.FileSourceCreateInput,
+    additional?: { select?: Prisma.FileSourceSelect },
+  ): Promise<FileSource> {
+    return this.getWriteClient().fileSource.create({ data, ...additional });
+  }
+
+  @HandlePrismaError(DbOperationType.UPDATE)
+  async update(
+    where: Prisma.FileSourceWhereUniqueInput,
+    data: Prisma.FileSourceUpdateInput,
+    additional?: { select?: Prisma.FileSourceSelect },
+  ): Promise<FileSource> {
+    return this.getWriteClient().fileSource.update({
+      where,
+      data,
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.DELETE)
+  async delete(where: Prisma.FileSourceWhereUniqueInput): Promise<FileSource> {
+    return this.getWriteClient().fileSource.delete({ where });
+  }
+}

package/template/apps/api/libs/domain/db/src/modules/file-source/index.ts

@@ -0,0 +1,2 @@
+export * from './file-source.service';
+export * from './file-source.module';

package/template/apps/api/libs/domain/db/src/modules/google-auth/google-auth.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { GoogleAuthService } from './google-auth.service';
+import { PrismaModule } from '@app/prisma';
+import { RedisModule } from '@app/redis';
+import { ConfigModule } from '@nestjs/config';
+
+@Module({
+  imports: [PrismaModule, RedisModule, ConfigModule],
+  providers: [GoogleAuthService],
+  exports: [GoogleAuthService],
+})
+export class GoogleAuthModule {}

package/template/apps/api/libs/domain/db/src/modules/google-auth/google-auth.service.ts

@@ -0,0 +1,101 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '@app/prisma';
+import { TransactionalServiceBase } from '@app/shared-db';
+import { HandlePrismaError, DbOperationType } from '@/utils/prisma-error.util';
+import { AppConfig } from '@/config/validation';
+import type { Prisma, GoogleAuth } from '@prisma/client';
+
+@Injectable()
+export class GoogleAuthService extends TransactionalServiceBase {
+  private appConfig: AppConfig;
+
+  constructor(
+    prisma: PrismaService,
+    private readonly config: ConfigService,
+  ) {
+    super(prisma);
+    this.appConfig = config.getOrThrow<AppConfig>('app');
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async get(
+    where: Prisma.GoogleAuthWhereInput,
+    additional?: { select?: Prisma.GoogleAuthSelect },
+  ): Promise<GoogleAuth | null> {
+    return this.getReadClient().googleAuth.findFirst({
+      where: { ...where, isDeleted: false },
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getById(
+    id: string,
+    additional?: { select?: Prisma.GoogleAuthSelect },
+  ): Promise<GoogleAuth | null> {
+    return this.getReadClient().googleAuth.findUnique({
+      where: { sub: id, isDeleted: false },
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async list(
+    where: Prisma.GoogleAuthWhereInput,
+    pagination?: {
+      orderBy?: Prisma.GoogleAuthOrderByWithRelationInput;
+      limit?: number;
+      page?: number;
+    },
+    additional?: { select?: Prisma.GoogleAuthSelect },
+  ): Promise<{ list: GoogleAuth[]; total: number; page: number; limit: number }> {
+    const {
+      orderBy = { createdAt: 'desc' },
+      limit = this.appConfig.MaxPageSize,
+      page = 1,
+    } = pagination || {};
+    const skip = (page - 1) * limit;
+
+    const [list, total] = await Promise.all([
+      this.getReadClient().googleAuth.findMany({
+        where: { ...where, isDeleted: false },
+        orderBy,
+        take: limit,
+        skip,
+        ...additional,
+      }),
+      this.getReadClient().googleAuth.count({
+        where: { ...where, isDeleted: false },
+      }),
+    ]);
+
+    return { list, total, page, limit };
+  }
+
+  @HandlePrismaError(DbOperationType.CREATE)
+  async create(
+    data: Prisma.GoogleAuthCreateInput,
+    additional?: { select?: Prisma.GoogleAuthSelect },
+  ): Promise<GoogleAuth> {
+    return this.getWriteClient().googleAuth.create({ data, ...additional });
+  }
+
+  @HandlePrismaError(DbOperationType.UPDATE)
+  async update(
+    where: Prisma.GoogleAuthWhereUniqueInput,
+    data: Prisma.GoogleAuthUpdateInput,
+    additional?: { select?: Prisma.GoogleAuthSelect },
+  ): Promise<GoogleAuth> {
+    return this.getWriteClient().googleAuth.update({
+      where,
+      data,
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.DELETE)
+  async delete(where: Prisma.GoogleAuthWhereUniqueInput): Promise<GoogleAuth> {
+    return this.getWriteClient().googleAuth.delete({ where });
+  }
+}

package/template/apps/api/libs/domain/db/src/modules/google-auth/index.ts

@@ -0,0 +1,2 @@
+export * from './google-auth.service';
+export * from './google-auth.module';

package/template/apps/api/libs/domain/db/src/modules/message/index.ts

@@ -0,0 +1,2 @@
+export * from './message.service';
+export * from './message.module';

package/template/apps/api/libs/domain/db/src/modules/message/message.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { MessageService } from './message.service';
+import { PrismaModule } from '@app/prisma';
+
+@Module({
+  imports: [PrismaModule],
+  providers: [MessageService],
+  exports: [MessageService],
+})
+export class MessageDbModule {}

package/template/apps/api/libs/domain/db/src/modules/message/message.service.ts

@@ -0,0 +1,314 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '@app/prisma';
+import { TransactionalServiceBase } from '@app/shared-db';
+import { HandlePrismaError, DbOperationType } from '@/utils/prisma-error.util';
+import type { Prisma, Message, MessageRecipient } from '@prisma/client';
+
+/**
+ * Message DB Service
+ * 消息数据库服务层
+ *
+ * 职责：
+ * - 消息的CRUD操作
+ * - 消息接收记录管理
+ * - 未读消息统计
+ * - 批量操作支持
+ */
+@Injectable()
+export class MessageService extends TransactionalServiceBase {
+  constructor(prisma: PrismaService) {
+    super(prisma);
+  }
+
+  /**
+   * Create a new message with recipients
+   * 创建新消息并指定接收者
+   */
+  @HandlePrismaError(DbOperationType.CREATE)
+  async createMessage(
+    data: Prisma.MessageCreateInput,
+    recipientIds: string[],
+  ): Promise<Message> {
+    return this.getWriteClient().message.create({
+      data: {
+        ...data,
+        recipients: {
+          create: recipientIds.map((userId) => ({
+            userId,
+            isRead: false,
+          })),
+        },
+      },
+      include: {
+        recipients: true,
+        sender: {
+          select: {
+            id: true,
+            nickname: true,
+            avatarFileId: true,
+          },
+        },
+      },
+    });
+  }
+
+  /**
+   * Create a system message for specific users
+   * 创建系统消息
+   */
+  @HandlePrismaError(DbOperationType.CREATE)
+  async createSystemMessage(
+    title: string | null,
+    content: any,
+    recipientIds: string[],
+    metadata?: any,
+  ): Promise<Message> {
+    return this.createMessage(
+      {
+        type: 'SYSTEM',
+        title,
+        content,
+        metadata,
+      },
+      recipientIds,
+    );
+  }
+
+  /**
+   * Create a milestone notification message
+   * 创建里程碑通知消息
+   */
+  @HandlePrismaError(DbOperationType.CREATE)
+  async createMilestoneMessage(
+    userId: string,
+    milestone: number,
+    content: any,
+    metadata?: any,
+  ): Promise<Message> {
+    return this.createMessage(
+      {
+        type: 'MILESTONE',
+        title: `Streak Milestone: ${milestone} days!`,
+        content,
+        metadata: {
+          ...metadata,
+          milestone,
+        },
+      },
+      [userId],
+    );
+  }
+
+  /**
+   * Get message by ID
+   * 根据ID获取消息
+   */
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getById(id: string): Promise<Message | null> {
+    return this.getReadClient().message.findUnique({
+      where: { id, isDeleted: false },
+      include: {
+        recipients: {
+          where: { isDeleted: false },
+          include: {
+            user: {
+              select: {
+                id: true,
+                nickname: true,
+                avatarFileId: true,
+              },
+            },
+          },
+        },
+        sender: {
+          select: {
+            id: true,
+            nickname: true,
+            avatarFileId: true,
+          },
+        },
+      },
+    });
+  }
+
+  /**
+   * Get user's messages (received)
+   * 获取用户接收到的消息列表
+   */
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getUserMessages(
+    userId: string,
+    options?: {
+      isRead?: boolean;
+      type?: string;
+      limit?: number;
+      offset?: number;
+    },
+  ) {
+    const { isRead, type, limit = 20, offset = 0 } = options || {};
+
+    const where: Prisma.MessageRecipientWhereInput = {
+      userId,
+      isDeleted: false,
+      ...(isRead !== undefined && { isRead }),
+      message: {
+        isDeleted: false,
+        ...(type && { type }),
+      },
+    };
+
+    const [list, total] = await Promise.all([
+      this.getReadClient().messageRecipient.findMany({
+        where,
+        orderBy: { createdAt: 'desc' },
+        take: limit,
+        skip: offset,
+        include: {
+          message: {
+            include: {
+              sender: {
+                select: {
+                  id: true,
+                  nickname: true,
+                  avatarFileId: true,
+                },
+              },
+            },
+          },
+          user: {
+            select: {
+              id: true,
+              nickname: true,
+              avatarFileId: true,
+            },
+          },
+        },
+      }),
+      this.getReadClient().messageRecipient.count({ where }),
+    ]);
+
+    return { list, total };
+  }
+
+  /**
+   * Get unread message count for user
+   * 获取用户未读消息数量
+   */
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getUnreadCount(userId: string): Promise<number> {
+    return this.getReadClient().messageRecipient.count({
+      where: {
+        userId,
+        isRead: false,
+        isDeleted: false,
+        message: {
+          isDeleted: false,
+        },
+      },
+    });
+  }
+
+  /**
+   * Mark messages as read
+   * 标记消息为已读
+   */
+  @HandlePrismaError(DbOperationType.UPDATE)
+  async markAsRead(userId: string, messageIds: string[]): Promise<number> {
+    const result = await this.getWriteClient().messageRecipient.updateMany({
+      where: {
+        userId,
+        messageId: { in: messageIds },
+        isRead: false,
+        isDeleted: false,
+      },
+      data: {
+        isRead: true,
+        readAt: new Date(),
+      },
+    });
+
+    return result.count;
+  }
+
+  /**
+   * Mark all messages as read for user
+   * 标记用户所有消息为已读
+   */
+  @HandlePrismaError(DbOperationType.UPDATE)
+  async markAllAsRead(userId: string): Promise<number> {
+    const result = await this.getWriteClient().messageRecipient.updateMany({
+      where: {
+        userId,
+        isRead: false,
+        isDeleted: false,
+      },
+      data: {
+        isRead: true,
+        readAt: new Date(),
+      },
+    });
+
+    return result.count;
+  }
+
+  /**
+   * Delete message (soft delete)
+   * 删除消息（软删除）
+   */
+  @HandlePrismaError(DbOperationType.DELETE)
+  async deleteMessage(id: string): Promise<Message> {
+    return this.getWriteClient().message.update({
+      where: { id },
+      data: { isDeleted: true },
+    });
+  }
+
+  /**
+   * Delete message recipient (soft delete)
+   * 删除消息接收记录（软删除）
+   */
+  @HandlePrismaError(DbOperationType.DELETE)
+  async deleteMessageRecipient(
+    userId: string,
+    messageId: string,
+  ): Promise<MessageRecipient> {
+    return this.getWriteClient().messageRecipient.updateMany({
+      where: {
+        userId,
+        messageId,
+      },
+      data: { isDeleted: true },
+    }) as any;
+  }
+
+  /**
+   * Get message recipient by ID
+   * 根据ID获取消息接收记录
+   */
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getRecipientById(id: string): Promise<MessageRecipient | null> {
+    return this.getReadClient().messageRecipient.findUnique({
+      where: { id, isDeleted: false },
+      include: {
+        message: {
+          include: {
+            sender: {
+              select: {
+                id: true,
+                nickname: true,
+                avatarFileId: true,
+              },
+            },
+          },
+        },
+        user: {
+          select: {
+            id: true,
+            nickname: true,
+            avatarFileId: true,
+          },
+        },
+      },
+    });
+  }
+}

package/template/apps/api/libs/domain/db/src/modules/mobile-auth/index.ts

@@ -0,0 +1,2 @@
+export * from './mobile-auth.service';
+export * from './mobile-auth.module';

package/template/apps/api/libs/domain/db/src/modules/mobile-auth/mobile-auth.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { MobileAuthService } from './mobile-auth.service';
+import { PrismaModule } from '@app/prisma';
+import { RedisModule } from '@app/redis';
+import { ConfigModule } from '@nestjs/config';
+
+@Module({
+  imports: [PrismaModule, RedisModule, ConfigModule],
+  providers: [MobileAuthService],
+  exports: [MobileAuthService],
+})
+export class MobileAuthModule {}

package/template/apps/api/libs/domain/db/src/modules/mobile-auth/mobile-auth.service.ts

@@ -0,0 +1,101 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '@app/prisma';
+import { TransactionalServiceBase } from '@app/shared-db';
+import { HandlePrismaError, DbOperationType } from '@/utils/prisma-error.util';
+import { AppConfig } from '@/config/validation';
+import type { Prisma, MobileAuth } from '@prisma/client';
+
+@Injectable()
+export class MobileAuthService extends TransactionalServiceBase {
+  private appConfig: AppConfig;
+
+  constructor(
+    prisma: PrismaService,
+    private readonly config: ConfigService,
+  ) {
+    super(prisma);
+    this.appConfig = config.getOrThrow<AppConfig>('app');
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async get(
+    where: Prisma.MobileAuthWhereInput,
+    additional?: { select?: Prisma.MobileAuthSelect },
+  ): Promise<MobileAuth | null> {
+    return this.getReadClient().mobileAuth.findFirst({
+      where: { ...where, isDeleted: false },
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async getById(
+    id: string,
+    additional?: { select?: Prisma.MobileAuthSelect },
+  ): Promise<MobileAuth | null> {
+    return this.getReadClient().mobileAuth.findUnique({
+      where: { mobile: id, isDeleted: false },
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.QUERY)
+  async list(
+    where: Prisma.MobileAuthWhereInput,
+    pagination?: {
+      orderBy?: Prisma.MobileAuthOrderByWithRelationInput;
+      limit?: number;
+      page?: number;
+    },
+    additional?: { select?: Prisma.MobileAuthSelect },
+  ): Promise<{ list: MobileAuth[]; total: number; page: number; limit: number }> {
+    const {
+      orderBy = { createdAt: 'desc' },
+      limit = this.appConfig.MaxPageSize,
+      page = 1,
+    } = pagination || {};
+    const skip = (page - 1) * limit;
+
+    const [list, total] = await Promise.all([
+      this.getReadClient().mobileAuth.findMany({
+        where: { ...where, isDeleted: false },
+        orderBy,
+        take: limit,
+        skip,
+        ...additional,
+      }),
+      this.getReadClient().mobileAuth.count({
+        where: { ...where, isDeleted: false },
+      }),
+    ]);
+
+    return { list, total, page, limit };
+  }
+
+  @HandlePrismaError(DbOperationType.CREATE)
+  async create(
+    data: Prisma.MobileAuthCreateInput,
+    additional?: { select?: Prisma.MobileAuthSelect },
+  ): Promise<MobileAuth> {
+    return this.getWriteClient().mobileAuth.create({ data, ...additional });
+  }
+
+  @HandlePrismaError(DbOperationType.UPDATE)
+  async update(
+    where: Prisma.MobileAuthWhereUniqueInput,
+    data: Prisma.MobileAuthUpdateInput,
+    additional?: { select?: Prisma.MobileAuthSelect },
+  ): Promise<MobileAuth> {
+    return this.getWriteClient().mobileAuth.update({
+      where,
+      data,
+      ...additional,
+    });
+  }
+
+  @HandlePrismaError(DbOperationType.DELETE)
+  async delete(where: Prisma.MobileAuthWhereUniqueInput): Promise<MobileAuth> {
+    return this.getWriteClient().mobileAuth.delete({ where });
+  }
+}

package/template/apps/api/libs/domain/db/src/modules/risk-detection-record/index.ts

@@ -0,0 +1,2 @@
+export * from './risk-detection-record.service';
+export * from './risk-detection-record.module';

package/template/apps/api/libs/domain/db/src/modules/risk-detection-record/risk-detection-record.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { RiskDetectionRecordService } from './risk-detection-record.service';
+import { PrismaModule } from '@app/prisma';
+import { RedisModule } from '@app/redis';
+import { ConfigModule } from '@nestjs/config';
+
+@Module({
+  imports: [PrismaModule, RedisModule, ConfigModule],
+  providers: [RiskDetectionRecordService],
+  exports: [RiskDetectionRecordService],
+})
+export class RiskDetectionRecordModule {}