hwj-common-lib/index.js

微信小程序云开发通用模块库，支持灵活的环境配置

const env = require('./env')
const error = require('./error')
const auth = require('./auth')
const database = require('./database')
const Cache = require('./cache')
const cloud = require('wx-server-sdk')

// 配置存储
let configOverride = null

/**
 * 配置库的环境和选项
 * @param {Object} config 配置对象
 * @param {string} config.CLOUD_ENV 云环境ID
 * @param {string} config.TOKEN_SECRET JWT密钥
 * @param {string} config.TOKEN_EXPIRES_IN JWT过期时间
 * @returns {Object} 当前配置
 */
function configure(config = {}) {
  configOverride = {
    ...config
  }
  
  // 如果配置了云环境，立即初始化
  if (configOverride.CLOUD_ENV) {
    initializeCloud(configOverride.CLOUD_ENV)
  }
  
  return getCurrentConfig()
}

/**
 * 获取当前配置
 * @returns {Object} 当前配置
 */
function getCurrentConfig() {
  return {
    CLOUD_ENV: 
      (configOverride && configOverride.CLOUD_ENV) || 
      process.env.CLOUD_ENV || 
      env.CLOUD_ENV,
    TOKEN_SECRET: 
      (configOverride && configOverride.TOKEN_SECRET) || 
      process.env.TOKEN_SECRET || 
      env.TOKEN_SECRET,
    TOKEN_EXPIRES_IN: 
      (configOverride && configOverride.TOKEN_EXPIRES_IN) || 
      process.env.TOKEN_EXPIRES_IN || 
      env.TOKEN_EXPIRES_IN,
    CACHE: env.CACHE,
    COLLECTIONS: env.COLLECTIONS
  }
}

/**
 * 初始化云环境
 * @param {string} cloudEnv 云环境ID
 */
function initializeCloud(cloudEnv) {
  if (!cloudEnv) {
    console.error('警告: 未提供云环境ID，云函数可能无法正常工作')
    return
  }
  
  if (cloudEnv === 'please-configure-your-own-cloud-env') {
    console.error('错误: 您需要配置自己的云环境ID')
    return
  }
  
  try {
    cloud.init({
      env: cloudEnv,
      traceUser: true
    })
    console.log(`已初始化云环境: ${cloudEnv}`)
  } catch (err) {
    console.error('初始化云环境失败:', err)
  }
}

// 获取当前配置
const currentConfig = getCurrentConfig()

// 初始化云环境（兼容旧代码）
if (!configOverride) {
  initializeCloud(currentConfig.CLOUD_ENV)
}

module.exports = {
  // 配置方法
  configure,
  getCurrentConfig,
  initializeCloud,
  
  // 环境配置
  get CLOUD_ENV() { return getCurrentConfig().CLOUD_ENV },
  get TOKEN_SECRET() { return getCurrentConfig().TOKEN_SECRET },
  get TOKEN_EXPIRES_IN() { return getCurrentConfig().TOKEN_EXPIRES_IN },
  CACHE: env.CACHE,
  COLLECTIONS: env.COLLECTIONS,

  // 错误处理
  ValidationError: error.ValidationError,
  BusinessError: error.BusinessError,
  LoginError: error.LoginError,
  TokenError: error.TokenError,
  DeviceError: error.DeviceError,
  errorHandler: error.errorHandler,

  // 认证相关
  generateToken: auth.generateToken,
  verifyToken: auth.verifyToken,
  auth: auth.auth,

  // 数据库操作
  db: database.db,
  _: database._,
  $: database.$,
  Database: database.Database,

  // 缓存操作
  Cache
}

// 获取IP地址
async function getIp(event, context) {
  try {
    const { TCB_SOURCE_IP } = cloud.getWXContext()
    return {
      success: true,
      data: {
        ip: TCB_SOURCE_IP || '127.0.0.1'
      }
    }
  } catch (error) {
    console.error('获取IP失败：', error)
    return error.errorHandler(error)
  }
}

// 云函数入口
exports.main = async (event, context) => {
  try {
    const { action } = event
    if (!action) {
      throw new error.ValidationError('缺少操作类型')
    }

    switch (action) {
      case 'getIp':
        return await getIp(event, context)
      default:
        throw new error.ValidationError('未知的操作类型: ' + action)
    }
  } catch (error) {
    console.error('云函数执行失败：', error)
    return error.errorHandler(error)
  }
}