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

package/request/innerapi.ts

@@ -0,0 +1,1648 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+import FormData = require("form-data");
+import { Stream } from "stream";
+import { Order } from "../context/db/impl/order"
+import { Criterion } from "../kunlun/operator/impl/logic";
+import { IInnerAPIRequest, OpenSDKGetRecordsReq, UploadFileResp } from "./interface";
+import * as common from "@byted-apaas/server-common-node";
+
+import { streamToBuffer } from '@jorgeferrero/stream-to-buffer';
+import { notifyModel } from "../constants/constants";
+
+import {
+    getDebugExtraInfo,
+    getNamespaceForOpenAndFaaSSDK,
+    getTriggerCtx,
+    transFlowVariableToMap,
+    transMapToFlowVariable
+} from './common';
+import {
+    ExecutionInfo,
+    ExecutionResult,
+    RevokeExecutionOptions
+} from "@byted-apaas/server-common-node/context/workflow/workflow";
+import { AppCtx } from "../application/application";
+import { InternalError, InvalidParamError } from "@byted-apaas/server-common-node/utils/exceptions";
+
+const rpc = (common as any).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?: boolean) {
+    let ctx;
+    try {
+        ctx = await rpc.rebuildRpcCtx(isTransUser);
+    } catch (err) {
+        throw new exceptions.InternalError(`RebuildRpcCtx failed: ${err.message}`)
+    }
+    return ctx;
+}
+
+function post(baseResp: any) {
+    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 as any)["is_system_error"] === "true") {
+            throw new exceptions.InternalError(`${msg} [${baseResp.KStatusCode}]`)
+        }
+        throw new exceptions.InvalidParamError(`${msg} [${baseResp.KStatusCode}]`)
+    }
+}
+
+async function createRecordBySync(objectApiName: string, record: object) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await 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: string, recordID: number, record: object) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await 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: string, recordID: number) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await 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: string, records: object[]) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await 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: string, recordMap: Record<number, object>) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await 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: string, recordIDs: number[]) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    let recordIDList: Array<bigint> = new Array();
+    recordIDs.forEach(
+        (v: number, idx: number) => {
+            recordIDList.push(BigInt(v));
+        }
+    );
+    param.Namespace = await 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: string, records: object[]) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await 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: Array<number> = new Array();
+    let errMap: Map<number, string> = new Map();
+    resp.RecordIDs.forEach(
+        (v: bigint, idx: number) => {
+            recordIDList.push(Number(v));
+        });
+    resp.ErrMap.forEach(
+        (v: string, k: bigint) => {
+            errMap.set(Number(k), v);
+        }
+    );
+    return {
+        record_ids: recordIDList,
+        err_map: errMap
+    };
+}
+
+async function updateRecordsBySync(objectApiName: string, recordMap: Record<number, object>) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    param.Namespace = await 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: Map<number, string> = new Map();
+    resp.ErrMap.forEach(
+        (v: string, k: bigint) => {
+            errMap.set(Number(k), v);
+        }
+    );
+    return { err_map: errMap };
+}
+
+async function deleteRecordsBySync(objectApiName: string, recordIDs: number[]) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.前置处理
+    let ctx = await pre();
+
+    // 3.构造 params
+    let param: any = {};
+    let task_id = utils.getTriggerTaskID();
+    let recordIDList: Array<bigint> = new Array();
+    recordIDs.forEach(
+        (v: number, idx: number) => {
+            recordIDList.push(BigInt(v));
+        }
+    );
+    param.Namespace = await 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: Map<number, string> = new Map();
+    resp.ErrMap.forEach(
+        (v: string, k: bigint) => {
+            errMap.set(Number(k), v);
+        }
+    );
+    return { err_map: errMap };
+}
+
+async function getRecordsOrCountByCriterion(objectApiName: string, criterion: string, order: Order[], ignoreBackLookupField: boolean, fieldApiNames: string[], offset: number, limit: number, needCount: boolean) {
+    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: any = {};
+    let orders = new Array();
+    order.forEach(
+        (v: Order, idx: number) => {
+            orders.push({
+                field: v.field,
+                type: v.type,
+                direction: v.direction,
+            } as any);
+
+        }
+    );
+    param.Namespace = await 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: any, instanceId: number, variables: object, variableTypes: object): Promise<void> {
+    // 1.前置处理
+    let ctx = await pre();
+
+    // 2.构造 params
+    let param: any = {};
+    param.NameSpace = await 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: Stream, expire: number): Promise<UploadFileResp> {
+    // 1.前置处理
+    let ctx = await pre();
+
+    // 2.构造 params
+    let param: any = {};
+    param.Data = await streamToBuffer(data as any);
+    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: string, filePath?: string): Promise<Buffer | void> {
+    // 1. build parameters
+    let param: any = {};
+    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: string, filePath?: string): Promise<Buffer | void> {
+    // 1. build parameters
+    let param: any = {};
+    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: any): Promise<number> {
+    // 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: any = {};
+    let modelKeySearchData = new Map<string, string>().set("icon_type", msg.icon as string);
+
+    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: any = {};
+    param.NameSpace = await getNamespaceForOpenAndFaaSSDK();
+    param.NotifyModelKey = 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: number, msg: any): Promise<void> {
+    // 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<string, string>();
+    let modelKeySearchData = new Map<string, string>().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: any = {};
+    param.NameSpace = await getNamespaceForOpenAndFaaSSDK();
+    param.TaskID = BigInt(msgId);
+    param.NotifyModelKey = 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: string): Promise<any> {
+    // 1. prepare request
+    let ctx = await pre();
+
+    // 2. build parameters
+    let param: any = {};
+    param.Namespace = await 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: string, fieldApiName: string): Promise<any> {
+    // 1. prepare request
+    let ctx = await pre();
+
+    // 2. build parameters
+    let param: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.ObjectAPIName = objectApiName;
+    param.FieldAPIName = fieldApiName;
+
+    // 3. do request
+    let resp: any;
+    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: number, operator: number, reason: string): Promise<void> {
+    // 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: any = {};
+    param.WorkflowInstanceID = BigInt(workflowInstanceId);
+    param.Operator = BigInt(operator);
+    param.Reason = reason;
+
+    // 4. do request
+    let resp: any;
+    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: Record<string, number>, operations: object[]): Promise<Map<string, number>> {
+    // 1. prepare args
+    // TODO: change placeholders type
+    let ph: Map<string, bigint> = new Map();
+    for (let key of Object.keys(placeholders)) {
+        ph.set(key, BigInt(placeholders[key]));
+    }
+
+    // 2. build parameters
+    let param: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.Placeholders = ph;
+    // TODO: change operations type
+    param.Operations = operations as any;
+    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<valueT>(key: string): Promise<valueT> {
+    // 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: any = {};
+        param.NameSpace = await getNamespaceForOpenAndFaaSSDK();
+        param.BizType = "GlobalVariables"
+        param.UsedBy = "UsedBySystem"
+        param.Filter = {
+            Offset: BigInt(offset * i),
+            Limit: BigInt(pageSize),
+        }
+
+        // 3. do request
+        let resp: any;
+        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: string, args: any[], namedArgs: Record<string, any>): Promise<string | any[]> {
+    // 1. build parameters
+    const queryData = JSON.stringify({
+        "query": oql,
+        "args": args,
+        "named_args": namedArgs,
+        "compat": true
+    });
+
+    // 2. prepare args
+    let param: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.QueryData = Buffer.from(queryData);
+
+    // 3. prepare request
+    let ctx = await pre();
+
+    // 4. do request
+    let resp: any;
+    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: string, record: object): Promise<any> {
+    // 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: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.ObjectAPIName = objectApiName;
+    param.Record = record;
+
+    // 4. do request
+    let resp: any;
+    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: string, recordID: number, record: object): Promise<any> {
+    // 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: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.ObjectAPIName = objectApiName;
+    param.RecordID = BigInt(recordID);
+    param.Record = record;
+
+    // 4. do request
+    let resp: any;
+    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: string, recordID: number): Promise<any> {
+    // 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: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.ObjectAPIName = objectApiName;
+    param.RecordID = BigInt(recordID);
+
+    // 4. do request
+    let resp: any;
+    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: string, records: object[]): Promise<any> {
+    // 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: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.ObjectAPIName = objectApiName;
+    param.Records = records;
+
+    // 4. do request
+    let resp: any;
+    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: string, recordMap: Record<number, object>): Promise<any> {
+    // 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: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.ObjectAPIName = objectApiName;
+    param.RecordMap = recordMap;
+
+    // 4. do request
+    let resp: any;
+    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: string, recordIDs: number[]): Promise<any> {
+    // 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: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.ObjectAPIName = objectApiName;
+    param.RecordIDs = recordIDs;
+
+    // 4. do request
+    let resp: any;
+    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: string, param: OpenSDKGetRecordsReq): Promise<any | number> {
+    // 1. prepare args
+    if (param.limit <= 0 || param.limit > 200) {
+        param.limit = 200;
+    }
+    let req: any;
+    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: any[] = [];
+    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: any;
+    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: string, data: Buffer): Promise<any> {
+    // 1. prepare args
+    let param: any;
+    param.Name = fileName;
+    param.EncryptType = 1; // no encrypt
+    param.Data = data;
+
+    // 2. prepare request
+    let ctx = await pre();
+
+    // 3. do request
+    let resp: any;
+    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: string, data: Buffer): Promise<any> {
+    // 1. prepare args
+    let param: any;
+    param.EncryptType = 1; // no encrypt
+    param.Data = data;
+
+    // 2. prepare request
+    let ctx = await pre();
+
+    // 3. do request
+    let resp: any;
+    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: string): Promise<Buffer> {
+    // 1. prepare args
+    let param: any;
+    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;
+}
+
+export class RequestRpc implements IInnerAPIRequest {
+
+    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: string, record: object): any {
+    }
+
+    updateRecordBySync(objectApiName: string, recordID: number, record: object): any {
+    }
+
+    deleteRecordBySync(objectApiName: string, recordID: number): any {
+    }
+
+    createRecordsByAsync(objectApiName: string, records: object[]): any {
+    }
+
+    updateRecordsByAsync(objectApiName: string, recordMap: Record<number, object>): any {
+    }
+
+    deleteRecordsByAsync(objectApiName: string, recordIDs: number[]): any {
+    }
+
+    createRecordsBySync(objectApiName: string, records: object[]): any {
+    }
+
+    updateRecordsBySync(objectApiName: string, recordMap: Record<number, object>): any {
+    }
+
+    deleteRecordsBySync(objectApiName: string, recordIDs: number[]): any {
+    }
+
+    getRecordsOrCountByCriterion(objectApiName: string, criterion: string | Criterion, order: Order[], ignoreBackLookupField: boolean, fieldApiNames: string[], offset: number, limit: number, needCount: boolean): any {
+    }
+
+    async updateWorkflowVariables(ctx: any, instanceId: number, variables: object, variableTypes: object): Promise<void> {
+    }
+
+    async uploadFile(data: Stream, expire: number): Promise<UploadFileResp> {
+        return null;
+    }
+
+    async downloadFileByID(fileID: string, filePath?: string): Promise<Buffer | void> {
+        return null;
+    }
+
+    async downloadFileByToken(fileToken: string, filePath?: string): Promise<Buffer | void> {
+        return null;
+    }
+
+    async createMessage(msg: any): Promise<number> {
+        return null;
+    }
+
+    async updateMessage(msgId: number, msg: any): Promise<void> {
+        return null;
+    }
+
+    async getFields(objectApiName: string): Promise<any> {
+    }
+
+    async getField(objectApiName: string, fieldApiName: string): Promise<any> {
+    }
+
+    async terminateWorkflowInstance(workflowInstanceId: number, operator: number, reason: string): Promise<void> {
+    }
+
+    async modifyRecordsWithTransaction(placeholders: Record<string, number>, operations: object[]): Promise<Map<string, number>> {
+        return null;
+    }
+
+    async getGlobalConfigByKey<valueT>(key: string): Promise<valueT> {
+        return null;
+    }
+
+    async oql(oql: string, args: any[], namedArgs: Record<string, any>): Promise<string | any[]> {
+        return [];
+    }
+
+    async invokeFuncSync(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+        return await invokeFuncSync(idOrName, params);
+    }
+
+    async invokeFuncWithAuth(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+        return await invokeFuncWithAuth(idOrName, params);
+    }
+
+    async createAsyncTaskV1(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+        return await createAsyncTaskV1(idOrName, params);
+    }
+
+    async createAsyncTaskV2(name: string, params: any): Promise<any> {
+        return await createAsyncTaskV2(name, params);
+    }
+
+    async getExecutionUserTaskInfo(executionId: bigint): Promise<any> {
+        return await getExecutionUserTaskInfo(executionId);
+    }
+
+    async executeFlow(APIName: string, options: any): Promise<ExecutionResult> {
+        return await executeFlow(APIName, options);
+    }
+
+    async revokeExecution(executionId: number, revokeOptions: RevokeExecutionOptions): Promise<void> {
+        return await revokeExecution(executionId, revokeOptions);
+    }
+
+    async getExecutionInfo(executionId: number): Promise<ExecutionInfo> {
+        return await getExecutionInfo(executionId);
+    }
+
+    async getTenantInfo(appCtx: AppCtx): Promise<any> {
+        return await appCtx.credential.getTenantInfo();
+    }
+
+    // open sdk empty implement
+    openSDKCreateRecordBySync(objectApiName: string, record: object): any {
+    };
+
+    openSDKUpdateRecordBySync(objectApiName: string, recordID: number, record: object): any {
+    };
+
+    openSDKDeleteRecordBySync(objectApiName: string, recordID: number): any {
+    };
+
+    openSDKCreateRecordsBySync(objectApiName: string, records: object[]): any {
+    };
+
+    openSDKUpdateRecordsBySync(objectApiName: string, recordMap: Record<number, object>): any {
+    };
+
+    openSDKDeleteRecordsBySync(objectApiName: string, recordIDs: number[]): any {
+    };
+
+    openSDKGetRecords(objectApiName: string, param: OpenSDKGetRecordsReq) {
+    };
+
+    openSDKUploadFile(fileName: string, data: Buffer): any {
+    };
+
+    openSDKUploadAvatar(fileName: string, data: Buffer): any {
+    };
+
+    openSDKDownloadAvatar(imageID: string): any {
+    };
+}
+
+async function invokeFuncWithAuth(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+    let ctx = await pre(true);
+
+    let param: any = {};
+
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    if (idOrName.isInvokeByAPIName) {
+        param.ApiName = idOrName.APIName;
+    } else {
+        param.ApiID = idOrName.APIId;
+    }
+    param.Params = JSON.stringify(params);
+    param.Context = JSON.stringify(getTriggerCtx());
+
+    let resp: any = 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: { code: string, msg: string, data: any };
+    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: string, options: any): Promise<ExecutionResult> {
+    let ctx = await pre();
+
+    let param: any = {};
+
+    param.NameSpace = await getNamespaceForOpenAndFaaSSDK();
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+    param.FlowAPIName = APIName;
+    param.variables = JSON.stringify(transMapToFlowVariable(options.params));
+    param.LoopMasks = utils.getLoopMasks();
+
+    let resp: any = 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: any = [];
+    try {
+        if (resp.OutParams) {
+            outParams = JSON.parse(resp.OutParams);
+        }
+    } catch (e) {
+        throw new InternalError(`Execute OutParams in Result is invalid (${resp.OutParams}), err: ${e.message}`);
+    }
+
+    return {
+        executionId: Number(resp.ExecutionID),
+        status: resp.Status as any,
+        data: transFlowVariableToMap(outParams),
+        errCode: resp.errCode ? resp.errCode : undefined,
+        errMsg: resp.errMsg ? resp.errMsg : undefined,
+    };
+}
+
+export async function revokeExecution(executionId: number, revokeOptions: RevokeExecutionOptions): Promise<void> {
+    let ctx = await pre();
+
+    let param: any = {};
+
+    param.NameSpace = await getNamespaceForOpenAndFaaSSDK();
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+    param.ExecutionID = BigInt(executionId);
+    let reason: any = 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);
+}
+
+export async function getExecutionInfo(executionId: number): Promise<ExecutionInfo> {
+    let ctx = await pre();
+
+    let param: any = {};
+
+    param.NameSpace = await getNamespaceForOpenAndFaaSSDK();
+    param.ExecutionID = BigInt(executionId);
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+
+    let resp: any = 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 InternalError(`GetExecutionInfo Response is empty`)
+    }
+
+    let outParams: any = [];
+    try {
+        if (resp.ExecutionInfo.outParams) {
+            outParams = JSON.parse(resp.ExecutionInfo.outParams);
+        }
+    } catch (e) {
+        throw new InternalError(`GetExecutionInfo OutParams in Result is invalid (${resp.ExecutionInfo.outParams}), err: ${e.message}`);
+    }
+
+    return {
+        status: resp.ExecutionInfo.status as any,
+        data: transFlowVariableToMap(outParams),
+        errCode: resp.ExecutionInfo.errCode ? resp.ExecutionInfo.errCode : undefined,
+        errMsg: resp.ExecutionInfo.errMsg ? resp.ExecutionInfo.errMsg : undefined,
+    };
+}
+
+export async function getExecutionUserTaskInfo(executionId: bigint): Promise<any> {
+    let ctx = await pre();
+
+    let param: any = {};
+
+    param.NameSpace = await getNamespaceForOpenAndFaaSSDK();
+    param.ExecutionID = BigInt(executionId);
+    param.Operator = BigInt(utils.getUserIDFromCtx());
+
+    let resp: any = 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;
+}
+
+async function invokeFuncSync(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+    let ctx = await pre(true);
+
+    let param: any = {};
+    param.Namespace = await 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(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: any = {};
+    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: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+    let ctx = await pre(true);
+
+    let param: any = {};
+    param.Namespace = await 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(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: string, params: any): Promise<any> {
+    let ctx = await pre(true);
+
+    let param: any = {};
+    param.Namespace = await getNamespaceForOpenAndFaaSSDK();
+    param.APIAlias = APIName;
+    param.Params = JSON.stringify(params);
+    param.Context = JSON.stringify(getTriggerCtx());
+    param.TriggerType = utils.getTriggerType();
+    param.Extra = 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);
+}