import { createLogger } from '@maxtan/nest-core'

// 在应用启动时配置日志
createLogger() // 默认配置，日志输出到控制台和文件

import { logger } from '@maxtan/nest-core'

// 使用默认logger记录不同级别的日志
logger.info('普通信息')
logger.debug('调试信息')
logger.warn('警告信息')
logger.error('错误信息')

// 或使用 log 方法（需要指定级别）
logger.log('info', '普通信息')
logger.log('error', '错误信息', errorObject)

import { createLogger } from '@maxtan/nest-core'

// 自定义配置
createLogger({
  useConsole: true, // 是否输出到控制台，默认 true
  maxDays: 30, // 日志文件保留天数，默认 30 天
  maxSize: '20m', // 单个日志文件最大大小，默认 20MB
  sls: {
    // 阿里云 SLS 配置（可选）
    accessKeyId: 'your-ak',
    accessKeySecret: 'your-sk',
    projectName: 'your-project',
    logStoreName: 'your-logstore',
    // 可选配置
    endpoint: 'cn-hangzhou.log.aliyuncs.com',
    topic: 'nest-boot',
    source: 'source',
    env: 'production'
  }
})

import { NestFactory } from '@nestjs/core'
import { createLogger, WinstonLoggerService } from '@maxtan/nest-core'
import { AppModule } from './app.module'

async function bootstrap() {
  // 配置日志系统
  createLogger({
    useConsole: true,
    maxDays: 30,
    sls: {
      // SLS 配置...
    }
  })

  const app = await NestFactory.create(AppModule, {
    logger: new WinstonLoggerService() // 使用 Winston 作为 NestJS 日志服务
  })

  await app.listen(3000)
}
bootstrap()

import { CacheModule } from '@maxtan/nest-core'

@Module({
  imports: [
    CacheModule.forRoot(
      {
        url: 'redis://localhost:6379'
        // 其他 Redis 客户端选项
      },
      true // 第二个参数表示是否全局注册模块
    )
  ]
})
export class AppModule {}

import { Injectable } from '@nestjs/common'
import { CacheService } from '@maxtan/nest-core'

@Injectable()
export class YourService {
  constructor(private readonly cacheService: CacheService) {}

  async getData(key: string) {
    // 从缓存获取数据
    const cached = await this.cacheService.get(key)
    if (cached) return cached

    // 获取数据并缓存
    const data = await this.fetchData()
    await this.cacheService.set(key, JSON.stringify(data), 3600) // 缓存1小时
    return data
  }

  // 使用对象序列化
  async getObjectData(key: string) {
    // 自动 JSON 解析
    const cached = await this.cacheService.getObject<UserData>(key)
    if (cached) return cached

    const data = await this.fetchData()
    await this.cacheService.setObject(key, data, 3600) // 自动 JSON 序列化
    return data
  }

  // 批量操作
  async batchGet(keys: string[]) {
    return await this.cacheService.mget(...keys)
  }

  async batchSet(data: Record<string, any>) {
    await this.cacheService.mset(data)
  }

  // 计数器
  async incrementCounter(key: string) {
    return await this.cacheService.incr(key)
  }

  // 检查连接状态
  async checkHealth() {
    const isReady = await this.cacheService.isReady()
    return { redis: isReady ? 'healthy' : 'unhealthy' }
  }
}

import { Module } from '@nestjs/common'
import { OperationModule } from '@maxtan/nest-core'

@Module({
  imports: [
    // 基础使用 - 默认全局拦截所有控制器方法
    OperationModule.forRoot()
  ]
})
export class AppModule {}

import { Module } from '@nestjs/common'
import { OperationModule } from '@maxtan/nest-core'

@Module({
  imports: [
    OperationModule.forRoot({
      enabled: true, // 是否启用，默认 true
      excludePaths: ['/health', '/metrics'], // 排除不需要记录日志的路径
      global: true, // 是否全局注册，默认 true
      request: false, // 是否默认记录请求参数，默认 false
      response: false, // 是否默认记录响应结果，默认 false
      idField: 'id', // 用户ID字段名，默认 'id'
      nameField: 'name' // 用户名字段名，默认 'name'
    })
  ]
})
export class AppModule {}

import { Controller, Post, Put, Get, Body, Param } from '@nestjs/common'
import { Operation } from '@maxtan/nest-core'

@Controller('users')
export class UserController {
  // 不使用装饰器 - 自动记录日志（根据全局配置）
  @Post()
  async createUser(@Body() dto: CreateUserDto) {
    return this.userService.create(dto)
  }

  // 添加描述并记录请求和响应
  @Put(':id')
  @Operation({
    description: '更新用户信息',
    request: true, // 记录请求参数
    response: true // 记录响应结果
  })
  async updateUser(@Param('id') id: string, @Body() dto: UpdateUserDto) {
    return this.userService.update(id, dto)
  }

  // 仅记录请求，不记录响应
  @Post('login')
  @Operation({
    description: '用户登录',
    request: true
  })
  async login(@Body() dto: LoginDto) {
    return this.authService.login(dto)
  }

  // 禁用日志记录（如健康检查接口）
  @Get('health')
  @Operation({ disabled: true })
  async healthCheck() {
    return { status: 'ok' }
  }
}

// JWT payload 示例 1：使用标准字段
{
  "sub": "user_12345",
  "username": "john_doe"
}
// 提取结果：userId = "user_12345", username = "john_doe"

// JWT payload 示例 2：使用自定义字段
{
  "id": "12345",
  "name": "John Doe"
}
// 使用默认配置，提取结果：userId = "12345", username = "John Doe"

// JWT payload 示例 3：自定义配置
{
  "uid": "12345",
  "nickname": "JohnD"
}
// 使用配置 { idField: 'uid', nameField: 'nickname' }
// 提取结果：userId = "12345", username = "JohnD"

import { AuthModule } from '@maxtan/nest-core'

@Module({
  imports: [
    AuthModule.register({
      secret: 'your-jwt-secret-key'
    })
  ]
})
export class AppModule {}

import { AuthModule } from '@maxtan/nest-core'

@Module({
  imports: [
    AuthModule.register({
      secret: 'your-jwt-secret-key',
      signOptions: {
        expiresIn: '7d', // Token有效期7天
        issuer: 'your-app', // 发行方
        audience: 'your-users' // 目标用户
      }
    })
  ]
})
export class AppModule {}

import { Controller, Get, UseGuards } from '@nestjs/common'
import { AuthGuard } from '@maxtan/nest-core'

@Controller('protected')
@UseGuards(AuthGuard)
export class ProtectedController {
  @Get()
  getProtectedData() {
    return { message: '这是受保护的数据' }
  }
}

import { Module } from '@nestjs/common'
import { APP_GUARD } from '@nestjs/core'
import { AuthGuard, AuthModule } from '@maxtan/nest-core'

@Module({
  imports: [
    AuthModule.register({
      secret: 'your-jwt-secret-key'
    })
    // 其他模块...
  ],
  providers: [
    {
      provide: APP_GUARD,
      useClass: AuthGuard
    }
  ]
})
export class AppModule {}

import { Controller, Get } from '@nestjs/common'
import { AuthPublic } from '@maxtan/nest-core'

@Controller('public')
export class PublicController {
  @Get()
  @AuthPublic()
  getPublicData() {
    return { message: '这是公开数据，无需认证' }
  }
}

import { Controller, Get, Request, UseGuards } from '@nestjs/common'
import { AuthGuard } from '@maxtan/nest-core'

@Controller('profile')
@UseGuards(AuthGuard)
export class ProfileController {
  @Get()
  getProfile(@Request() req) {
    // req.user 包含了 JWT payload 中的信息
    return req.user
  }
}

import { Controller, Get, UseGuards } from '@nestjs/common'
import { AuthGuard, AuthDecorator } from '@maxtan/nest-core'

@Controller('profile')
@UseGuards(AuthGuard)
export class ProfileController {
  @Get()
  getProfile(@AuthDecorator() auth) {
    // auth 包含完整的认证用户信息
    return auth
  }

  @Get('username')
  getUsername(@AuthDecorator('username') username: string) {
    // 直接获取指定字段
    return { username }
  }

  @Get('data')
  getData(@AuthDecorator('data') data: any) {
    // 获取自定义数据字段
    return data
  }
}

import { JwtService } from '@nestjs/jwt'
import { Injectable } from '@nestjs/common'

@Injectable()
export class AuthService {
  constructor(private jwtService: JwtService) {}

  // 自定义 token 生成逻辑
  async generateToken(user: any) {
    // 自定义 payload 结构
    const payload = {
      sub: user.id, // 标准字段
      username: user.username, // 业务字段
      roles: user.roles, // 自定义字段
      permissions: user.perms, // 自定义字段
      customData: {
        // 任意嵌套结构
        department: user.dept,
        level: user.level
      }
    }

    // 使用自己的加密方式
    return this.jwtService.sign(payload, {
      algorithm: 'RS256', // 支持 RSA 非对称加密
      expiresIn: '7d'
      // 更多自定义配置...
    })
  }
}

@Get('profile')
getProfile(@AuthDecorator() auth) {
  // 可以访问所有自定义字段
  console.log(auth.roles)        // 自定义字段
  console.log(auth.permissions)  // 自定义字段
  console.log(auth.customData)   // 嵌套对象
  return auth
}

import { Entity, PrimaryColumn } from 'typeorm'
import { TypeOrmDocument } from '@maxtan/nest-core'

@Entity('users')
export class User extends TypeOrmDocument {
  @PrimaryColumn({ type: 'bigint' })
  id: string

  @Column()
  username: string

  @Column()
  email: string
}

// 插入时
const user = new User()
user.username = 'john'
// createdAt 和 updateAt 会自动设置为当前时间
await repository.save(user)

// 更新时
user.email = 'john@example.com'
// updateAt 会自动更新为当前时间，createdAt 保持不变
await repository.save(user)

import { IsNull, Not } from 'typeorm'

// 查询未删除的记录（推荐）
// 由于 deletedAt 默认 select: false，不需要额外过滤
const activeUsers = await repository.find()

// 如需显式过滤未删除记录
const activeUsers = await repository.find({
  where: { deletedAt: IsNull() }
})

// 查询已删除的记录（需显式选择 deletedAt）
const deletedUsers = await repository.find({
  where: { deletedAt: Not(IsNull()) },
  select: ['id', 'username', 'deletedAt'], // 必须显式指定
  withDeleted: true // TypeORM 选项
})

// 软删除（手动设置 deletedAt）
user.deletedAt = String(Date.now()) // 注意：deletedAt 是 string 类型
await repository.save(user)

// 恢复软删除的记录
user.deletedAt = null
await repository.save(user)

import { TypeOrmTimeTransformer } from '@maxtan/nest-core'

// TypeOrmTimeTransformer 自动处理 bigint 和 number 之间的转换
// - 存入数据库：number -> bigint
// - 从数据库读取：bigint -> number

const user = await repository.findOne({ where: { id: '123' } })
console.log(user.createdAt) // 1700000000000 (number)
console.log(typeof user.createdAt) // "number"

// 可以直接用于 JSON 响应和日期转换
return user // 自动序列化为数字
const date = new Date(user.createdAt) // 直接转换，无需 Number()

// 创建时设置创建者
const user = new User()
user.username = 'john'
user.createBy = currentUserId // 手动设置
await repository.save(user)

// 更新时设置更新者
user.email = 'john@example.com'
user.updateBy = currentUserId // 手动设置
await repository.save(user)

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
import { Observable } from 'rxjs'
import { tap } from 'rxjs/operators'

@Injectable()
export class AuditInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest()
    const userId = request.user?.id // 从认证信息中获取用户ID

    return next.handle().pipe(
      tap((data) => {
        // 在保存实体前设置审计字段
        if (data && userId) {
          if (!data.createBy) data.createBy = userId
          data.updateBy = userId
        }
      })
    )
  }
}

import { createSnowflake } from '@maxtan/nest-core'

// 创建默认雪花算法实例
const snowflake = createSnowflake()

// 生成唯一ID
const id = snowflake.generateSnowflakeId()
console.log(id) // 输出类似: "1234567890123456789"

import { createSnowflake } from '@maxtan/nest-core'

// 自定义工作节点ID和起始时间
const snowflake = createSnowflake({
  workerId: 1, // 工作节点ID
  epoch: new Date('2024-01-01T00:00:00.000Z') // 自定义起始时间
})

const id = snowflake.generateSnowflakeId()

interface SnowflakeOptions {
  workerId?: number // 工作节点ID，默认为1
  epoch?: number | string | Date // 起始时间，默认为2024-01-01 00:00:00 UTC
}

// 这两个调用会返回同一个实例
const snowflake1 = createSnowflake({ workerId: 1 })
const snowflake2 = createSnowflake({ workerId: 1 })

console.log(snowflake1 === snowflake2) // true

import { APP_FILTER } from '@nestjs/core'
import { AllExceptionsFilter } from '@maxtan/nest-core'

@Module({
  providers: [
    {
      provide: APP_FILTER,
      useClass: AllExceptionsFilter
    }
  ]
})
export class AppModule {}