cloudworker-proxy/examples/serverless/node_modules/@serverless/platform-client-china/src/api.js

An api gateway for cloudflare workers

'use strict';

/*
 * SERVERLESS PLATFORM SDK: API
 */

const { Serverless: TencentAPI, Cam: TencentCAM } = require('@serverless/utils-china');
const utils = require('./utils');

let tencentAPI = null;
async function getTencentAPIInstance(sdk) {
  if (!tencentAPI) {
    let SecretId;
    let SecretKey;
    let Token;
    if (process.env.TENCENT_SECRET_ID && process.env.TENCENT_SECRET_KEY) {
      SecretId = process.env.TENCENT_SECRET_ID;
      SecretKey = process.env.TENCENT_SECRET_KEY;
      Token = process.env.TENCENT_TOKEN;
    } else if (sdk.platformAccessKey) {
      ({ SecretId, SecretKey, Token } = utils.parseCredentialFromTempAccessKey(
        sdk.platformAccessKey
      ));
    }
    if (sdk.skipRoleBinding) {
      console.log('skip sdk role binding for tencent');
    } else {
      const roleBinder = new TencentCAM.BindRole.BindRole({
        SecretId,
        SecretKey,
        Token,
      });
      await roleBinder.bindQCSRole();
    }
    const platformStageRegion =
      process.env.SERVERLESS_PLATFORM_STAGE === 'dev' ? 'ap-shanghai' : 'ap-guangzhou';
    // create instance of TencentSDK
    tencentAPI = new TencentAPI({
      appid: process.env.TENCENT_APP_ID,
      secret_id: SecretId,
      secret_key: SecretKey,
      options: {
        region: platformStageRegion,
        token: Token,
        sdkAgent: sdk.agent,
      },
    });
  }
  return tencentAPI;
}

function processTencentAPIResponse(response) {
  if (response && response.Body) {
    let payload;
    let payloadBody;
    try {
      payload = JSON.parse(response.Body);
      payloadBody = JSON.parse(payload.body);
    } catch (e) {
      console.log('bad response from tencent', response);
      const err = new Error('bad response from tencent');
      err.resBody = response.Body;
      throw err;
    }
    if (payload.statusCode === 200) {
      return payloadBody;
    }
    const error = new Error(payloadBody.message);
    error.statusCode = payload.statusCode;
    throw error;
  }
  throw new Error('access Tencent API failed, get empty response');
}

const registryPackage = {
  get: async (packageName, version) => {
    const platformStageRegion =
      process.env.SERVERLESS_PLATFORM_STAGE === 'dev' ? 'ap-shanghai' : 'ap-guangzhou';
    // get doesn't require auth, so use static method on TencentAPI
    return processTencentAPIResponse(
      await TencentAPI.getPackage(packageName, version, {
        region: platformStageRegion,
      })
    );
  },

  list: async (orgUid, filter) => {
    const platformStageRegion =
      process.env.SERVERLESS_PLATFORM_STAGE === 'dev' ? 'ap-shanghai' : 'ap-guangzhou';
    // get doesn't require auth, so use static method on TencentAPI
    return processTencentAPIResponse(
      await TencentAPI.listPackages(
        {
          orgUid,
          isFeatured: filter.isFeatured,
        },
        {
          region: platformStageRegion,
        }
      )
    );
  },

  getHandlerFileName: () => {
    return utils.isChinaUser() ? 'handler.js' : '_handler.js';
  },

  prePublish: async (sdk, packageData) => {
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(await apiClient.preparePublishPackage(packageData));
  },

  postPublish: async (sdk, packageData) => {
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(await apiClient.postPublishPackage(packageData));
  },
};

const instance = {
  save: async (sdk, instanceData) => {
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(await apiClient.saveInstance({ instance: instanceData }));
  },

  get: async (sdk, orgName, appName, stageName, instanceName, options) => {
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(
      await apiClient.getInstance({
        orgUid: orgName,
        orgName,
        appName,
        stageName,
        instanceName,
        options,
      })
    );
  },

  list: async (sdk, orgUid, orgName) => {
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(await apiClient.listInstances({ orgUid, orgName }));
  },

  getUploadUrls: async (sdk, orgName) => {
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(
      await apiClient.getUploadUrls({
        orgUid: orgName,
        orgName,
        options: {
          useGlobalStore: utils.useGlobalStore(),
        },
      })
    );
  },

  run: async (sdk, instanceData, method, credentials, options, size) => {
    // setup role that used to execute deployment
    if (instanceData.globalOptions && instanceData.globalOptions.configRole) {
      instanceData.roleName = instanceData.globalOptions.configRole;
    }
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(
      await apiClient.runComponent({ instance: instanceData, method, credentials, options, size })
    );
  },

  runFinish: async (sdk, instanceData, method) => {
    const apiClient = await getTencentAPIInstance(sdk);
    return processTencentAPIResponse(
      await apiClient.runFinishComponent({ instance: instanceData, method })
    );
  },
};

module.exports = {
  registryPackage,
  instance,
};