// index.js - 云函数入口文件
exports.main = async (event, context) => {
  // 1. 解析云函数入参
  const { a, b } = event;

  // 2. 执行业务逻辑
  const sum = a + b;

  // 3. 返回结果
  return {
    sum,
    timestamp: Date.now(),
    requestId: context.eventID,
  };
};

exports.main = async (event, context) => {
  // ❌ 不推荐：Promise 链式调用
  getList().then((res) => {
    // do something...
  });

  // ✅ 推荐：使用 async/await
  const res = await getList();
  // do something...
};

exports.main = async (event, context) => {
  // 获取环境变量
  const dbUrl = process.env.DATABASE_URL;
  const apiKey = process.env.API_KEY;
  const nodeEnv = process.env.NODE_ENV || 'development';

  // 使用环境变量进行配置
  const config = {
    database: dbUrl,
    apiKey: apiKey,
    debug: nodeEnv === 'development',
  };

  return {
    message: '环境变量获取成功',
    environment: nodeEnv,
  };
};

exports.main = async (event, context) => {
  // 检查必需的环境变量
  const requiredEnvVars = ['DATABASE_URL', 'API_KEY'];
  const missingVars = requiredEnvVars.filter((varName) => !process.env[varName]);

  if (missingVars.length > 0) {
    throw new Error(`缺少必需的环境变量: ${missingVars.join(', ')}`);
  }

  // 安全地使用环境变量
  const config = {
    dbUrl: process.env.DATABASE_URL,
    apiKey: process.env.API_KEY,
    timeout: parseInt(process.env.TIMEOUT) || 5000,
  };

  return { success: true, config };
};

cloud-function/
├── index.js        # 云函数入口文件（CommonJS）
├── entry.mjs       # ES Module 入口文件
└── src
    └── util.mjs       # 业务逻辑模块，命名可自定义

// index.js - 云函数入口文件
exports.main = async (event, context) => {
  try {
    // 动态导入 ES Module 入口文件
    const { entry } = await import('./entry.mjs');
    return await entry(event, context);
  } catch (error) {
    console.error('云函数执行失败:', error);
    return {
      success: false,
      error: error.message,
      requestId: context.eventID,
    };
  }
};

// entry.mjs - ES Module 入口文件
import { getUserList } from './src/util.mjs';

/**
 * ES Module 入口函数
 * @param {Object} event - 事件对象
 * @param {Object} context - 上下文对象
 * @returns {Promise<Object>} 处理结果
 */
export const entry = async (event, context) => {
  return getUserList(event, context);
};

// src/util.mjs - 业务逻辑模块
export const getUserList = async (event) => {
  // 业务逻辑处理
  return {
    success: true,
    data: [],
  };
};

exports.main = async (event, context) => {
  try {
    // 参数验证
    if (!event.userId) {
      throw new Error('缺少必需参数: userId');
    }

    // 业务逻辑处理
    const result = await processUserData(event.userId);

    return {
      success: true,
      data: result,
    };
  } catch (error) {
    // 记录错误日志
    context.logger.logError(error, {
      event,
      requestId: context.eventID,
    });

    // 返回友好的错误信息
    return {
      success: false,
      error: error.message,
      requestId: context.eventID,
    };
  }
};

exports.main = async (event, context) => {
  // 记录访问日志
  // 注意：logAccesslog 的第一个参数是 LogLevel 枚举值（'info'、'warn'、'error'、'debug'）
  context.logger.logAccesslog('info', '处理用户请求', {
    userId: event.userId,
    action: 'getUserInfo',
  });

  // 使用 console 输出会自动记录为用户代码日志
  console.log('开始处理业务逻辑');
  console.info('用户ID:', event.userId);
  console.warn('这是一个警告');
  console.error('这是一个错误');

  return {
    success: true,
    data: {},
  };
};

exports.main = async (event, context) => {
  const startTime = Date.now();

  try {
    // 使用并行处理提升性能
    const promises = event.items.map((item) => processItem(item));
    const results = await Promise.all(promises);

    const duration = Date.now() - startTime;
    console.log(`函数执行耗时: ${duration}ms`);

    return {
      success: true,
      data: results,
      duration,
    };
  } catch (error) {
    console.error('执行错误:', error);
    throw error;
  }
};

exports.main = async (event, context) => {
  // 分批处理大数据，避免内存溢出
  const batchSize = parseInt(process.env.BATCH_SIZE) || 100;
  const results = [];

  for (let i = 0; i < event.data.length; i += batchSize) {
    const batch = event.data.slice(i, i + batchSize);
    const batchResult = await processBatch(batch);
    results.push(...batchResult);

    // 及时清理不需要的变量
    batch.length = 0;

    // 记录处理进度
    console.log(`已处理 ${Math.min(i + batchSize, event.data.length)}/${event.data.length} 条数据`);
  }

  return results;
};

exports.main = async (event, context) => {
  // GET 请求
  const getResponse = await context.request.get({
    url: 'https://api.example.com/data',
    headers: {
      Authorization: 'Bearer token',
    },
  });

  // POST 请求
  const postResponse = await context.request.post({
    url: 'https://api.example.com/data',
    data: {
      name: 'test',
      value: 123,
    },
  });

  // 文件上传
  const uploadResponse = await context.request.upload({
    url: 'https://api.example.com/upload',
    file: event.file.buffer, // 文件 Buffer
    name: 'file.jpg',
    data: {
      folder: 'images',
    },
  });

  // 文件下载
  const downloadResponse = await context.request.download({
    url: 'https://api.example.com/file.pdf',
  });

  return {
    getData: getResponse.data,
    postData: postResponse.data,
    uploadResult: uploadResponse.data,
    downloadData: downloadResponse.data,
    downloadUrl: downloadResponse.tempFilePath,
  };
};