@byted-apaas/server-sdk-node 0.0.1-beta.3

package/request/innerapi.js

@@ -0,0 +1,1412 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExecutionUserTaskInfo = exports.getExecutionInfo = exports.revokeExecution = exports.RequestRpc = void 0;
+const common = require("@byted-apaas/server-common-node");
+const stream_to_buffer_1 = require("@jorgeferrero/stream-to-buffer");
+const constants_1 = require("../constants/constants");
+const common_1 = require("./common");
+const exceptions_1 = require("@byted-apaas/server-common-node/utils/exceptions");
+const rpc = common.rpc;
+const exceptions = common.exceptions;
+const utils = common.utils;
+const fs = require("fs");
+const checkUtils = common.checkUtils;
+const path = require('path');
+async function pre(isTransUser) {
+    let ctx;
+    try {
+        ctx = await rpc.rebuildRpcCtx(isTransUser);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`RebuildRpcCtx failed: ${err.message}`);
+    }
+    return ctx;
+}
+function post(baseResp) {
+    if (!baseResp) {
+        throw new exceptions.InternalError(`Call InnerAPI resp is empty`);
+    }
+    if (baseResp.KStatusCode !== "") {
+        let msg = baseResp.KStatusMessage;
+        if (baseResp.StatusMessage !== "") {
+            msg = baseResp.StatusMessage;
+        }
+        if (baseResp.extra["is_system_error"] === "true") {
+            throw new exceptions.InternalError(`${msg} [${baseResp.KStatusCode}]`);
+        }
+        throw new exceptions.InvalidParamError(`${msg} [${baseResp.KStatusCode}]`);
+    }
+}
+async function createRecordBySync(objectApiName, record) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.Data = utils.stringify(record);
+    param.Operator = BigInt(-1);
+    if (task_id) {
+        param.TaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().CreateRecordBySync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return { _id: Number(resp.RecordID) };
+}
+async function updateRecordBySync(objectApiName, recordID, record) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.RecordID = BigInt(recordID);
+    param.Data = utils.stringify(record);
+    param.Operator = BigInt(-1);
+    if (task_id) {
+        param.TaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().UpdateRecordBySync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return;
+}
+async function deleteRecordBySync(objectApiName, recordID) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.RecordID = BigInt(recordID);
+    param.Operator = BigInt(-1);
+    if (task_id) {
+        param.TaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().DeleteRecordBySync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return;
+}
+async function createRecordsByAsync(objectApiName, records) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.Data = utils.stringify(records);
+    param.OperatorID = BigInt(-1);
+    if (task_id) {
+        param.AutomationTaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchCreateRecordByAsync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return { taskID: Number(resp.TaskID) };
+}
+async function updateRecordsByAsync(objectApiName, recordMap) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.Data = utils.stringify(recordMap);
+    param.OperatorID = BigInt(-1);
+    if (task_id) {
+        param.AutomationTaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchUpdateRecordByAsync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return { taskID: Number(resp.TaskID) };
+}
+async function deleteRecordsByAsync(objectApiName, recordIDs) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    let recordIDList = new Array();
+    recordIDs.forEach((v, idx) => {
+        recordIDList.push(BigInt(v));
+    });
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.RecordIDList = recordIDList;
+    param.OperatorID = BigInt(-1);
+    if (task_id) {
+        param.AutomationTaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchDeleteRecordByAsync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return { taskID: Number(resp.TaskID) };
+}
+async function createRecordsBySync(objectApiName, records) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.Data = utils.stringify(records);
+    param.OperatorID = BigInt(-1);
+    if (task_id) {
+        param.AutomationTaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchCreateRecordBySync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    let recordIDList = new Array();
+    let errMap = new Map();
+    resp.RecordIDs.forEach((v, idx) => {
+        recordIDList.push(Number(v));
+    });
+    resp.ErrMap.forEach((v, k) => {
+        errMap.set(Number(k), v);
+    });
+    return {
+        record_ids: recordIDList,
+        err_map: errMap
+    };
+}
+async function updateRecordsBySync(objectApiName, recordMap) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.Data = utils.stringify(recordMap);
+    param.OperatorID = BigInt(-1);
+    if (task_id) {
+        param.AutomationTaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchUpdateRecordBySync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    let errMap = new Map();
+    resp.ErrMap.forEach((v, k) => {
+        errMap.set(Number(k), v);
+    });
+    return { err_map: errMap };
+}
+async function deleteRecordsBySync(objectApiName, recordIDs) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let task_id = utils.getTriggerTaskID();
+    let recordIDList = new Array();
+    recordIDs.forEach((v, idx) => {
+        recordIDList.push(BigInt(v));
+    });
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.RecordIDs = recordIDList;
+    param.OperatorID = BigInt(-1);
+    if (task_id) {
+        param.AutomationTaskID = BigInt(task_id);
+    }
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchDeleteRecordBySync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    let errMap = new Map();
+    resp.ErrMap.forEach((v, k) => {
+        errMap.set(Number(k), v);
+    });
+    return { err_map: errMap };
+}
+async function getRecordsOrCountByCriterion(objectApiName, criterion, order, ignoreBackLookupField, fieldApiNames, offset, limit, needCount) {
+    if (limit > 1000) {
+        limit = 1000;
+    }
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+    // 2.前置处理
+    let ctx = await pre();
+    // 3.构造 params
+    let param = {};
+    let orders = new Array();
+    order.forEach((v, idx) => {
+        orders.push({
+            field: v.field,
+            type: v.type,
+            direction: v.direction,
+        });
+    });
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIAlias = objectApiName;
+    param.Criterion = criterion;
+    param.Order = orders;
+    param.IgnoreBackLookupField = ignoreBackLookupField;
+    param.Limit = BigInt(limit);
+    param.offset = BigInt(offset);
+    param.FieldAPIAPIAliases = fieldApiNames;
+    param.NeedFilterUserPermission = false;
+    param.NeedTotalCount = needCount;
+    // 4.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchGetRecordWithCriterionV3(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    if (needCount) {
+        return Number(resp.Total);
+    }
+    else {
+        return JSON.parse(resp.DataList);
+    }
+}
+async function updateWorkflowVariables(iCtx, instanceId, variables, variableTypes) {
+    // 1.前置处理
+    let ctx = await pre();
+    // 2.构造 params
+    let param = {};
+    param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.WorkflowInstanceID = BigInt(instanceId);
+    param.Variables = variables;
+    // 3.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().UpdateVariablesByAPIAlias(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 4.后置处理
+    post(resp.BaseResp);
+    return;
+}
+async function uploadFile(data, expire) {
+    // 1.前置处理
+    let ctx = await pre();
+    // 2.构造 params
+    let param = {};
+    param.Data = await (0, stream_to_buffer_1.streamToBuffer)(data);
+    param.Name = "file";
+    param.EncryptType = 1;
+    param.PermissionConf = {
+        PermissionType: "",
+        PermissionInfo: "",
+        IgnoreUserID: true
+    };
+    if (expire) {
+        param.ExpireSecond = expire;
+    }
+    // 3.发起请求
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().UploadAttachmentForRPC(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 4.后置处理
+    post(resp.BaseResp);
+    return {
+        id: resp.ID,
+        token: resp.Token,
+        size: resp.Size,
+        mimeType: resp.MimeType,
+        name: resp.Filename,
+    };
+}
+async function downloadFileByID(fileID, filePath) {
+    // 1. build parameters
+    let param = {};
+    param.FileID = fileID;
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().DownloadFile(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 4. deal with response
+    post(resp.BaseResp);
+    if (filePath) {
+        checkUtils.checkFile(filePath);
+        utils.mkdirs(path.dirname(filePath));
+        fs.writeFileSync(filePath, resp.Data);
+        return;
+    }
+    else {
+        return resp.Data;
+    }
+}
+async function downloadFileByToken(fileToken, filePath) {
+    // 1. build parameters
+    let param = {};
+    param.Token = fileToken;
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().DownloadAttachment(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 4. deal with response
+    post(resp.BaseResp);
+    if (filePath) {
+        checkUtils.checkFile(filePath);
+        utils.mkdirs(path.dirname(filePath));
+        fs.writeFileSync(filePath, resp.Data);
+        return;
+    }
+    else {
+        return resp.Data;
+    }
+}
+async function createMessage(msg) {
+    // 1. prepare args
+    if (!msg.icon) {
+        throw new exceptions.InvalidParamError(`parameter icon is required!`);
+    }
+    if (typeof (msg.icon) != 'string') {
+        throw new exceptions.InvalidParamError(`Invalid format of parameter icon, icon should be string.`);
+    }
+    let params = {};
+    let modelKeySearchData = new Map().set("icon_type", msg.icon);
+    let receiverIds = msg["target_users"] || [];
+    if (!(receiverIds instanceof Array)) {
+        throw new exceptions.InvalidParamError(`Invalid format of parameter target_users, target_users should be array.`);
+    }
+    if (receiverIds.length === 0) {
+        throw new exceptions.InvalidParamError(`parameter target_users is required!`);
+    }
+    let percent = msg["percent"];
+    if (percent !== undefined && percent !== null) {
+        if (typeof (percent) != 'number') {
+            throw new exceptions.InvalidParamError(`Invalid format of parameter percent, percent should be number.`);
+        }
+        if (percent < 0 || percent > 100) {
+            throw new exceptions.InvalidParamError(`Invalid value of parameter percent, the value should be in range [0, 100].`);
+        }
+        else {
+            modelKeySearchData.set("percent", JSON.stringify(percent));
+        }
+    }
+    // kunlun类型
+    if (common.checkUtils.isObject(msg)) {
+        for (let key of Object.keys(msg)) {
+            if (common.fieldType.isKFieldType(msg[key])) {
+                // instanceof 改动6
+                // if (msg[key] instanceof fieldType.Multilingual) {
+                if (common.fieldType.isKFieldTypeMultilingual((msg[key]))) {
+                    let value = JSON.stringify(msg[key].toJSON());
+                    params[key] = JSON.stringify({ "value": value });
+                }
+                else {
+                    params[key] = JSON.stringify(msg[key].toJSON());
+                }
+            }
+            else {
+                params[key] = JSON.stringify(msg[key]);
+            }
+        }
+    }
+    // 2. prepare for request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.NotifyModelKey = constants_1.notifyModel.key;
+    param.ReceiverIDs = receiverIds;
+    param.ParamsRawData = params;
+    param.Percent = percent;
+    param.ModelKeySearchData = modelKeySearchData;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().CreateNotifyTask(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+    return Number(resp.TaskID);
+}
+async function updateMessage(msgId, msg) {
+    // 1. prepare args
+    if (!msgId) {
+        throw new exceptions.InvalidParamError(`parameter msgId is required!`);
+    }
+    if (typeof (msgId) != 'number') {
+        throw new exceptions.InvalidParamError(`Invalid format of parameter msgId, msgId should be number.`);
+    }
+    if (!msg.icon) {
+        throw new exceptions.InvalidParamError(`parameter icon is required!`);
+    }
+    if (typeof (msg.icon) != 'string') {
+        throw new exceptions.InvalidParamError(`Invalid format of parameter icon, icon should be string.`);
+    }
+    let params = new Map();
+    let modelKeySearchData = new Map().set("icon_type", msg.icon);
+    let percent = msg["percent"];
+    if (percent !== undefined && percent !== null) {
+        if (typeof (percent) != 'number') {
+            throw new exceptions.InvalidParamError(`Invalid format of parameter percent, percent should be number.`);
+        }
+        if (percent < 0 || percent > 100) {
+            throw new exceptions.InvalidParamError(`Invalid value of parameter percent in message ${msgId}, the value should be in range [0, 100].`);
+        }
+        else {
+            modelKeySearchData.set("percent", JSON.stringify(percent));
+        }
+    }
+    // kunlun类型
+    if (common.checkUtils.isObject(msg)) {
+        for (let key of Object.keys(msg)) {
+            if (common.fieldType.isKFieldType(msg[key])) {
+                // instanceof 改动7
+                // if (msg[key] instanceof fieldType.Multilingual) {
+                if (common.fieldType.isKFieldTypeMultilingual(msg[key])) {
+                    let value = JSON.stringify(msg[key].toJSON());
+                    params.set(key, JSON.stringify({ "value": value }));
+                }
+                else {
+                    params.set(key, JSON.stringify(msg[key].toJSON()));
+                }
+            }
+            else {
+                params.set(key, JSON.stringify(msg[key]));
+            }
+        }
+    }
+    // 2. prepare for request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.TaskID = BigInt(msgId);
+    param.NotifyModelKey = constants_1.notifyModel.key;
+    param.ParamsRawData = params;
+    param.Percent = percent;
+    param.ModelKeySearchData = modelKeySearchData;
+    param.IsBackground = true;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().UpdateNotifyTask(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function getFields(objectApiName) {
+    // 1. prepare request
+    let ctx = await pre();
+    // 2. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().GetObjectFields(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI getFields failed: ${err.message}`);
+    }
+    // 4.后置处理
+    post(resp.BaseResp);
+    try {
+        return JSON.parse(resp.Data);
+    }
+    catch (e) {
+        throw new exceptions.InternalError(`JSON parse failed: ${e.message}`);
+    }
+}
+async function getField(objectApiName, fieldApiName) {
+    // 1. prepare request
+    let ctx = await pre();
+    // 2. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    param.FieldAPIName = fieldApiName;
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().GetObjectField(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 4. deal with response
+    post(resp.BaseResp);
+    try {
+        return JSON.parse(resp.Data);
+    }
+    catch (e) {
+        throw new exceptions.InternalError(`JSON parse failed: ${e.message}`);
+    }
+}
+async function terminateWorkflowInstance(workflowInstanceId, operator, reason) {
+    // 1. prepare args
+    if (typeof (workflowInstanceId) !== "number") {
+        throw new exceptions.InvalidParamError(`The type of workflowInstanceId should be number, but ${typeof (workflowInstanceId)}.`);
+    }
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.WorkflowInstanceID = BigInt(workflowInstanceId);
+    param.Operator = BigInt(operator);
+    param.Reason = reason;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().TerminateWorkflowInstance(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function modifyRecordsWithTransaction(placeholders, operations) {
+    // 1. prepare args
+    // TODO: change placeholders type
+    let ph = new Map();
+    for (let key of Object.keys(placeholders)) {
+        ph.set(key, BigInt(placeholders[key]));
+    }
+    // 2. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.Placeholders = ph;
+    // TODO: change operations type
+    param.Operations = operations;
+    param.OperatorID = BigInt(-1);
+    const taskID = utils.getTriggerTaskID();
+    if (taskID) {
+        param.TaskID = BigInt(taskID);
+    }
+    // 3. prepare request
+    let ctx = await pre();
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().ModifyRecordsWithTX(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+    return resp.Placeholders;
+}
+async function getGlobalConfigByKey(key) {
+    // 1. prepare request
+    let ctx = await pre();
+    // 2. get all global configs by page
+    let pageSize = 100, offset = 0;
+    for (let i = 0;; i++) {
+        let param = {};
+        param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+        param.BizType = "GlobalVariables";
+        param.UsedBy = "UsedBySystem";
+        param.Filter = {
+            Offset: BigInt(offset * i),
+            Limit: BigInt(pageSize),
+        };
+        // 3. do request
+        let resp;
+        try {
+            resp = await rpc.getInnerAPICli().GetAllConfig(ctx, param);
+        }
+        catch (err) {
+            throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+        }
+        post(resp.BaseResp);
+        // 4. find the config
+        for (let config of resp.Configs) {
+            if (config.Key === key) {
+                return config.Value;
+            }
+        }
+        // 5. check if there is next page
+        if (resp.Configs.length < 100) {
+            break;
+        }
+    }
+    throw new exceptions.InvalidParamError(`undefined global variable (${key})`);
+}
+async function oql(oql, args, namedArgs) {
+    // 1. build parameters
+    const queryData = JSON.stringify({
+        "query": oql,
+        "args": args,
+        "named_args": namedArgs,
+        "compat": true
+    });
+    // 2. prepare args
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.QueryData = Buffer.from(queryData);
+    // 3. prepare request
+    let ctx = await pre();
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().QueryRecordsByOQL(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+    try {
+        return JSON.parse(resp.Rows ? resp.Rows : "[]");
+    }
+    catch (e) {
+        throw new exceptions.InternalError(`oql result parse failed: ${e.message}`);
+    }
+}
+async function openSDKCreateRecordBySync(objectApiName, record) {
+    // 1. prepare args
+    if (typeof (objectApiName) !== "string") {
+        throw new exceptions.InvalidParamError(`The type of objectApiName should be string, but ${typeof (objectApiName)}.`);
+    }
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    param.Record = record;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().CreateRecord(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function openSDKUpdateRecordBySync(objectApiName, recordID, record) {
+    // 1. prepare args
+    if (typeof (objectApiName) !== "string") {
+        throw new exceptions.InvalidParamError(`The type of objectApiName should be string, but ${typeof (objectApiName)}.`);
+    }
+    if (typeof (recordID) !== "number") {
+        throw new exceptions.InvalidParamError(`The type of recordID should be number, but ${typeof (recordID)}.`);
+    }
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    param.RecordID = BigInt(recordID);
+    param.Record = record;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().UpdateRecord(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function openSDKDeleteRecordBySync(objectApiName, recordID) {
+    // 1. prepare args
+    if (typeof (objectApiName) !== "string") {
+        throw new exceptions.InvalidParamError(`The type of objectApiName should be string, but ${typeof (objectApiName)}.`);
+    }
+    if (typeof (recordID) !== "number") {
+        throw new exceptions.InvalidParamError(`The type of recordID should be number, but ${typeof (recordID)}.`);
+    }
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    param.RecordID = BigInt(recordID);
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().DeleteRecord(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function openSDKCreateRecordsBySync(objectApiName, records) {
+    // 1. prepare args
+    if (typeof (objectApiName) !== "string") {
+        throw new exceptions.InvalidParamError(`The type of objectApiName should be string, but ${typeof (objectApiName)}.`);
+    }
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    param.Records = records;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchCreateRecords(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function openSDKUpdateRecordsBySync(objectApiName, recordMap) {
+    // 1. prepare args
+    if (typeof (objectApiName) !== "string") {
+        throw new exceptions.InvalidParamError(`The type of objectApiName should be string, but ${typeof (objectApiName)}.`);
+    }
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    param.RecordMap = recordMap;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchUpdateRecords(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function openSDKDeleteRecordsBySync(objectApiName, recordIDs) {
+    // 1. prepare args
+    if (typeof (objectApiName) !== "string") {
+        throw new exceptions.InvalidParamError(`The type of objectApiName should be string, but ${typeof (objectApiName)}.`);
+    }
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. build parameters
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ObjectAPIName = objectApiName;
+    param.RecordIDs = recordIDs;
+    // 4. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().BatchDeleteRecords(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5. deal with response
+    post(resp.BaseResp);
+}
+async function openSDKGetRecords(objectApiName, param) {
+    // 1. prepare args
+    if (param.limit <= 0 || param.limit > 200) {
+        param.limit = 200;
+    }
+    let req;
+    req.ObjectAPIAlias = objectApiName;
+    req.Filter = JSON.stringify(param.filter);
+    req.Limit = BigInt(param.limit);
+    req.Offset = BigInt(param.offset);
+    req.FiledAPIAlias = param.fields;
+    req.NeedTotalCount = param.count;
+    let sortList = [];
+    if (param.sort) {
+        param.sort.forEach((sort) => {
+            sortList.push({
+                FieldApiAlias: sort.field,
+                Type: sort.type,
+                Direction: sort.direction,
+            });
+        });
+    }
+    req.Sort = sortList;
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().GetRecordList(ctx, req);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 4. deal with response
+    post(resp.BaseResp);
+    // 5. return result
+    if (param.count) {
+        return resp.Total;
+    }
+    else {
+        return resp.Data;
+    }
+}
+;
+async function openSDKUploadFile(fileName, data) {
+    // 1. prepare args
+    let param;
+    param.Name = fileName;
+    param.EncryptType = 1; // no encrypt
+    param.Data = data;
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getAttachmentCli().UploadFileForRPC(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call Attachment failed: ${err.message}`);
+    }
+    // 4. deal with response
+    post(resp.BaseResp);
+    return resp;
+}
+async function openSDKUploadAvatar(fileName, data) {
+    // 1. prepare args
+    let param;
+    param.EncryptType = 1; // no encrypt
+    param.Data = data;
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getAttachmentCli().UploadAvatarForRPC(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call Attachment failed: ${err.message}`);
+    }
+    // 4. deal with response
+    post(resp.BaseResp);
+    return resp;
+}
+async function openSDKDownloadAvatar(imageID) {
+    // 1. prepare args
+    let param;
+    param.ImageID = imageID;
+    // 2. prepare request
+    let ctx = await pre();
+    // 3. do request
+    let resp;
+    try {
+        resp = await rpc.getAttachmentCli().DownloadAvatarForRPC(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call Attachment failed: ${err.message}`);
+    }
+    // 4. deal with response
+    post(resp.BaseResp);
+    return resp.Data;
+}
+class RequestRpc {
+    constructor() {
+        this.updateWorkflowVariables = updateWorkflowVariables;
+        this.createRecordBySync = createRecordBySync;
+        this.updateRecordBySync = updateRecordBySync;
+        this.deleteRecordBySync = deleteRecordBySync;
+        this.createRecordsByAsync = createRecordsByAsync;
+        this.updateRecordsByAsync = updateRecordsByAsync;
+        this.deleteRecordsByAsync = deleteRecordsByAsync;
+        this.createRecordsBySync = createRecordsBySync;
+        this.updateRecordsBySync = updateRecordsBySync;
+        this.deleteRecordsBySync = deleteRecordsBySync;
+        this.getRecordsOrCountByCriterion = getRecordsOrCountByCriterion;
+        this.uploadFile = uploadFile;
+        this.downloadFileByID = downloadFileByID;
+        this.downloadFileByToken = downloadFileByToken;
+        this.createMessage = createMessage;
+        this.updateMessage = updateMessage;
+        this.getFields = getFields;
+        this.getField = getField;
+        this.terminateWorkflowInstance = terminateWorkflowInstance;
+        this.modifyRecordsWithTransaction = modifyRecordsWithTransaction;
+        this.getGlobalConfigByKey = getGlobalConfigByKey;
+        this.oql = oql;
+        // open sdk api
+        this.openSDKCreateRecordBySync = openSDKCreateRecordBySync;
+        this.openSDKUpdateRecordBySync = openSDKUpdateRecordBySync;
+        this.openSDKDeleteRecordBySync = openSDKDeleteRecordBySync;
+        this.openSDKCreateRecordsBySync = openSDKCreateRecordsBySync;
+        this.openSDKUpdateRecordsBySync = openSDKUpdateRecordsBySync;
+        this.openSDKDeleteRecordsBySync = openSDKDeleteRecordsBySync;
+        this.openSDKGetRecords = openSDKGetRecords;
+        this.openSDKUploadFile = openSDKUploadFile;
+        this.openSDKUploadAvatar = openSDKUploadAvatar;
+        this.openSDKDownloadAvatar = openSDKDownloadAvatar;
+    }
+    createRecordBySync(objectApiName, record) {
+    }
+    updateRecordBySync(objectApiName, recordID, record) {
+    }
+    deleteRecordBySync(objectApiName, recordID) {
+    }
+    createRecordsByAsync(objectApiName, records) {
+    }
+    updateRecordsByAsync(objectApiName, recordMap) {
+    }
+    deleteRecordsByAsync(objectApiName, recordIDs) {
+    }
+    createRecordsBySync(objectApiName, records) {
+    }
+    updateRecordsBySync(objectApiName, recordMap) {
+    }
+    deleteRecordsBySync(objectApiName, recordIDs) {
+    }
+    getRecordsOrCountByCriterion(objectApiName, criterion, order, ignoreBackLookupField, fieldApiNames, offset, limit, needCount) {
+    }
+    async updateWorkflowVariables(ctx, instanceId, variables, variableTypes) {
+    }
+    async uploadFile(data, expire) {
+        return null;
+    }
+    async downloadFileByID(fileID, filePath) {
+        return null;
+    }
+    async downloadFileByToken(fileToken, filePath) {
+        return null;
+    }
+    async createMessage(msg) {
+        return null;
+    }
+    async updateMessage(msgId, msg) {
+        return null;
+    }
+    async getFields(objectApiName) {
+    }
+    async getField(objectApiName, fieldApiName) {
+    }
+    async terminateWorkflowInstance(workflowInstanceId, operator, reason) {
+    }
+    async modifyRecordsWithTransaction(placeholders, operations) {
+        return null;
+    }
+    async getGlobalConfigByKey(key) {
+        return null;
+    }
+    async oql(oql, args, namedArgs) {
+        return [];
+    }
+    async invokeFuncSync(idOrName, params) {
+        return await invokeFuncSync(idOrName, params);
+    }
+    async invokeFuncWithAuth(idOrName, params) {
+        return await invokeFuncWithAuth(idOrName, params);
+    }
+    async createAsyncTaskV1(idOrName, params) {
+        return await createAsyncTaskV1(idOrName, params);
+    }
+    async createAsyncTaskV2(name, params) {
+        return await createAsyncTaskV2(name, params);
+    }
+    async getExecutionUserTaskInfo(executionId) {
+        return await getExecutionUserTaskInfo(executionId);
+    }
+    async executeFlow(APIName, options) {
+        return await executeFlow(APIName, options);
+    }
+    async revokeExecution(executionId, revokeOptions) {
+        return await revokeExecution(executionId, revokeOptions);
+    }
+    async getExecutionInfo(executionId) {
+        return await getExecutionInfo(executionId);
+    }
+    async getTenantInfo(appCtx) {
+        return await appCtx.credential.getTenantInfo();
+    }
+    // open sdk empty implement
+    openSDKCreateRecordBySync(objectApiName, record) {
+    }
+    ;
+    openSDKUpdateRecordBySync(objectApiName, recordID, record) {
+    }
+    ;
+    openSDKDeleteRecordBySync(objectApiName, recordID) {
+    }
+    ;
+    openSDKCreateRecordsBySync(objectApiName, records) {
+    }
+    ;
+    openSDKUpdateRecordsBySync(objectApiName, recordMap) {
+    }
+    ;
+    openSDKDeleteRecordsBySync(objectApiName, recordIDs) {
+    }
+    ;
+    openSDKGetRecords(objectApiName, param) {
+    }
+    ;
+    openSDKUploadFile(fileName, data) {
+    }
+    ;
+    openSDKUploadAvatar(fileName, data) {
+    }
+    ;
+    openSDKDownloadAvatar(imageID) {
+    }
+    ;
+}
+exports.RequestRpc = RequestRpc;
+async function invokeFuncWithAuth(idOrName, params) {
+    let ctx = await pre(true);
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    if (idOrName.isInvokeByAPIName) {
+        param.ApiName = idOrName.APIName;
+    }
+    else {
+        param.ApiID = idOrName.APIId;
+    }
+    param.Params = JSON.stringify(params);
+    param.Context = JSON.stringify((0, common_1.getTriggerCtx)());
+    let resp = undefined;
+    try {
+        resp = await rpc.getInnerAPICli().InvokeFunctionWithAuth(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    post(resp.BaseResp);
+    let result;
+    try {
+        result = JSON.parse(resp.result);
+    }
+    catch (e) {
+        throw new exceptions.InternalError(`JSON parse failed for ${resp.result}`);
+    }
+    if (!result || result.code !== "0") {
+        throw new exceptions.InvalidParamError(`result is invalid for code: ${result ? result.code : ""} msg: ${result ? result.msg : ""}`);
+    }
+    return result.data;
+}
+async function executeFlow(APIName, options) {
+    let ctx = await pre();
+    let param = {};
+    param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+    param.FlowAPIName = APIName;
+    param.variables = JSON.stringify((0, common_1.transMapToFlowVariable)(options.params));
+    param.LoopMasks = utils.getLoopMasks();
+    let resp = undefined;
+    try {
+        resp = await rpc.getInnerAPICli().Execute(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    let outParams = [];
+    try {
+        if (resp.OutParams) {
+            outParams = JSON.parse(resp.OutParams);
+        }
+    }
+    catch (e) {
+        throw new exceptions_1.InternalError(`Execute OutParams in Result is invalid (${resp.OutParams}), err: ${e.message}`);
+    }
+    return {
+        executionId: Number(resp.ExecutionID),
+        status: resp.Status,
+        data: (0, common_1.transFlowVariableToMap)(outParams),
+        errCode: resp.errCode ? resp.errCode : undefined,
+        errMsg: resp.errMsg ? resp.errMsg : undefined,
+    };
+}
+async function revokeExecution(executionId, revokeOptions) {
+    let ctx = await pre();
+    let param = {};
+    param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+    param.ExecutionID = BigInt(executionId);
+    let reason = undefined;
+    if (revokeOptions && revokeOptions.reason) {
+        reason = {
+            En: revokeOptions.reason.en_US,
+            Zh: revokeOptions.reason.zh_CN
+        };
+    }
+    param.Reason = reason;
+    let resp = undefined;
+    try {
+        resp = await rpc.getInnerAPICli().RevokeExecution(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+}
+exports.revokeExecution = revokeExecution;
+async function getExecutionInfo(executionId) {
+    let ctx = await pre();
+    let param = {};
+    param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ExecutionID = BigInt(executionId);
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+    let resp = undefined;
+    try {
+        resp = await rpc.getInnerAPICli().GetExecutionInfo(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    if (!resp || !resp.ExecutionInfo) {
+        throw new exceptions_1.InternalError(`GetExecutionInfo Response is empty`);
+    }
+    let outParams = [];
+    try {
+        if (resp.ExecutionInfo.outParams) {
+            outParams = JSON.parse(resp.ExecutionInfo.outParams);
+        }
+    }
+    catch (e) {
+        throw new exceptions_1.InternalError(`GetExecutionInfo OutParams in Result is invalid (${resp.ExecutionInfo.outParams}), err: ${e.message}`);
+    }
+    return {
+        status: resp.ExecutionInfo.status,
+        data: (0, common_1.transFlowVariableToMap)(outParams),
+        errCode: resp.ExecutionInfo.errCode ? resp.ExecutionInfo.errCode : undefined,
+        errMsg: resp.ExecutionInfo.errMsg ? resp.ExecutionInfo.errMsg : undefined,
+    };
+}
+exports.getExecutionInfo = getExecutionInfo;
+async function getExecutionUserTaskInfo(executionId) {
+    let ctx = await pre();
+    let param = {};
+    param.NameSpace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.ExecutionID = BigInt(executionId);
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+    let resp = undefined;
+    try {
+        resp = await rpc.getInnerAPICli().GetExecutionUserTaskInfo(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return resp.taskList;
+}
+exports.getExecutionUserTaskInfo = getExecutionUserTaskInfo;
+async function invokeFuncSync(idOrName, params) {
+    let ctx = await pre(true);
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    if (idOrName.isInvokeByAPIName) {
+        param.FunctionName = "";
+        param.APIAlias = idOrName.APIName;
+    }
+    else {
+        param.FunctionName = idOrName.APIId;
+        param.APIAlias = "";
+    }
+    param.Params = JSON.stringify(params);
+    param.Context = JSON.stringify((0, common_1.getTriggerCtx)());
+    param.TriggerType = utils.getTriggerType();
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().InvokeFuncSync(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    let result = {};
+    try {
+        result = JSON.parse(resp.Result);
+    }
+    catch (e) {
+        throw new exceptions.InternalError(`Parse Result failed: ${e.message}`);
+    }
+    if (result && result.code === "0") {
+        return result.data;
+    }
+    throw new exceptions.InternalError(`[${result.code}] ${result.msg}`);
+}
+async function createAsyncTaskV1(idOrName, params) {
+    let ctx = await pre(true);
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    if (idOrName.isInvokeByAPIName) {
+        param.Alias = idOrName.APIName;
+        param.Name = ""; // required
+    }
+    else {
+        param.Name = idOrName.APIId;
+    }
+    param.Params = JSON.stringify(params);
+    param.Context = JSON.stringify((0, common_1.getTriggerCtx)());
+    param.TriggerType = utils.getTriggerType();
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().CreateAsyncTaskOld(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return Number(resp.TaskID);
+}
+async function createAsyncTaskV2(APIName, params) {
+    let ctx = await pre(true);
+    let param = {};
+    param.Namespace = await (0, common_1.getNamespaceForOpenAndFaaSSDK)();
+    param.APIAlias = APIName;
+    param.Params = JSON.stringify(params);
+    param.Context = JSON.stringify((0, common_1.getTriggerCtx)());
+    param.TriggerType = utils.getTriggerType();
+    param.Extra = (0, common_1.getDebugExtraInfo)();
+    let resp;
+    try {
+        resp = await rpc.getInnerAPICli().CreateAsyncTask(ctx, param);
+    }
+    catch (err) {
+        throw new exceptions.InternalError(`Call InnerAPI failed: ${err.message}`);
+    }
+    // 5.后置处理
+    post(resp.BaseResp);
+    return Number(resp.TaskID);
+}