@byted-apaas/server-sdk-node 0.0.2-beta.1

package/request/openapi.ts

@@ -0,0 +1,1220 @@
+import FormData = require("form-data");
+import {Stream} from "stream";
+import {notifyModel} from "../constants/constants";
+import * as common from "@byted-apaas/server-common-node";
+import {Order} from "../context/db/impl/order"
+import {Criterion} from "../kunlun/operator/impl/logic";
+import {openapiHttpPath as coreOapiHttpPath} from "./constants"
+import {IInnerAPIRequest, OpenSDKGetRecordsReq, UploadFileResp} from "./interface";
+import {headers} from "@byted-apaas/server-common-node/constants/constants";
+import {
+    ExecutionInfo,
+    ExecutionResult,
+    FlowTaskInfo,
+    RevokeExecutionOptions
+} from "@byted-apaas/server-common-node/context/workflow/workflow";
+import {AppCtx} from "../application/application";
+import {
+    getDebugExtraInfo,
+    getNamespaceForOpenAndFaaSSDK,
+    transFlowVariableToMap,
+    transMapToFlowVariable
+} from "./common";
+
+const nodeCls = require("node-cls");
+
+const fs = require('fs');
+const path = require('path');
+const commonHttp = common.http;
+const openapi = common.http.openapi;
+const openapiHttpPath = common.http.openapiHttpPath;
+const replaceKeys = common.http.replaceKeys;
+const exceptions = common.exceptions;
+const fieldType = common.fieldType;
+const utils = common.utils;
+const checkUtils = common.checkUtils;
+
+export async function updateWorkflowVariables(ctx: any, instanceId: number, variables: object, variableTypes: object) {
+    let options = commonHttp.getOptions(null, openapiHttpPath.workflowUpdateVariablesV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    // 2.请求
+    options.json = {
+        "operator": -1,
+        "workflowInstanceID": instanceId,
+        "variables": JSON.parse(variables as any),
+        "variableTypes": JSON.parse(variableTypes as any),
+    };
+
+    await openapi.doRequest(null, urlPath, options);
+}
+
+async function createRecordBySync(objectApiName: string, record: object) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.createRecordBySyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 3.请求
+    options.json = {
+        "operator": -1,
+        "data": record,
+    }
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["task_id"] = task_id;
+    }
+
+    let data = await openapi.doRequest(null, urlPath, options)
+
+    if (data && data.record_id) {
+        return {_id: data.record_id};
+    }
+
+    if (data && data.recordID) {
+        return {_id: data.recordID};
+    }
+
+    return data;
+}
+
+async function updateRecordBySync(objectApiName: string, recordID: number, record: object) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.updateRecordBySyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 3.请求
+    options.json = {
+        "operator": -1,
+        "record_id": recordID,
+        "data": record,
+    }
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["task_id"] = task_id;
+    }
+
+    return openapi.doRequest(null, urlPath, options);
+}
+
+async function deleteRecordBySync(objectApiName: string, recordID: number) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.deleteRecordBySyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 3.请求
+    options.json = {
+        "operator": -1,
+        "record_id": recordID,
+    }
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["task_id"] = task_id;
+    }
+
+    return openapi.doRequest(null, urlPath, options);
+}
+
+async function createRecordsByAsync(objectApiName: string, records: object[]) {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.createRecordsByAsyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = {
+        "operator": -1,
+        "data": records,
+    };
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["automation_task_id"] = task_id;
+    }
+    return openapi.doRequest(null, urlPath, options);
+}
+
+async function updateRecordsByAsync(objectApiName: string, recordMap: Record<number, object>) {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.updateRecordsByAsyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = {
+        "operator": -1,
+        "data": recordMap,
+    };
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["automation_task_id"] = task_id;
+    }
+    return openapi.doRequest(null, urlPath, options);
+}
+
+async function deleteRecordsByAsync(objectApiName: string, recordIDs: number[]) {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.deleteRecordsByAsyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = {
+        "operator": -1,
+        "record_id_list": recordIDs,
+    };
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["automation_task_id"] = task_id;
+    }
+    return openapi.doRequest(null, urlPath, options);
+}
+
+async function createRecordsBySync(objectApiName: string, records: object[]) {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.mCreateRecordsBySyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = {
+        "operator": -1,
+        "data": records,
+    };
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["automation_task_id"] = task_id;
+    }
+    return openapi.doRequest(null, urlPath, options);
+}
+
+async function updateRecordsBySync(objectApiName: string, recordMap: Record<number, object>) {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.mUpdateRecordsBySyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = {
+        "operator": -1,
+        "data": recordMap,
+    };
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["automation_task_id"] = task_id;
+    }
+    return openapi.doRequest(null, urlPath, options);
+}
+
+async function deleteRecordsBySync(objectApiName: string, recordIDs: number[]) {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.mDeleteRecordsBySyncV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = {
+        "operator": -1,
+        "record_id_list": recordIDs,
+    };
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        options.json["automation_task_id"] = task_id;
+    }
+    return openapi.doRequest(null, urlPath, options);
+}
+
+function handleResponse(data: Record<string, unknown>, needCount: boolean) {
+    // 返回数据的特殊处理
+    if (needCount) {
+        if (checkUtils.isObject(data) && data["total"]) {
+            return data["total"]
+        }
+        return 0;
+    } else {
+        if (checkUtils.isObject(data) && data["data_list"]) {
+            return data["data_list"];
+        }
+        return [];
+    }
+}
+
+async function getRecordsOrCountByCriterion(objectApiName: string, criterion: string | Criterion, order: Order[], ignoreBackLookupField: boolean, fieldApiNames: string[], offset: number, limit: number, needCount: boolean) {
+    if (limit > 1000) {
+        limit = 1000;
+    }
+
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InternalError("objectApiName is empty");
+    }
+
+    // 2.获取 options
+    let options = commonHttp.getOptions(null, needCount ? openapiHttpPath.mGetCountByCriterionV2 : openapiHttpPath.mGetRecordByCriterionV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 3.请求
+    options.json = {
+        "criterion": JSON.parse(criterion as any),
+        "order": order,
+        "ignore_back_lookup_field": ignoreBackLookupField,
+        "field_api_names": fieldApiNames,
+        "offset": offset,
+        "limit": limit,
+        "need_filter_user_permission": false,
+        "need_total_count": needCount,
+    };
+
+    let data = await openapi.doRequest(null, urlPath, options);
+    return handleResponse(data, needCount)
+}
+
+/**
+ * 上传文件
+ *
+ * @param ctx
+ * @param datas：filePath；Stream
+ * @param expire(seconds)
+ * @returns {Promise<*|string>}
+ */
+async function uploadFile(datas: Stream, expire: number = 0): Promise<UploadFileResp> {
+    let formData = new FormData();
+    formData.append('file', datas);
+    formData.append('expireSeconds', expire.toString());
+    formData.append('ignoreUserId', 'true');
+    let formHeaders = formData.getHeaders();
+
+    // 1.获取config
+    let options = commonHttp.getOptions(null, openapiHttpPath.uploadAttachment);
+    let urlPath: string = options._reqPath;
+
+    options.responseType = 'buffer';
+    for (let key of Object.keys(formHeaders)) {
+        options.headers[key] = formHeaders[key];
+    }
+    options.body = formData;
+
+    // 2.请求
+    return await openapi.doRequest(null, urlPath, options);
+}
+
+async function downloadFileByID(id: string, filePath?: string): Promise<Buffer | void> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.downloadFile);
+    let urlPath = options._reqPath.replace(replaceKeys.fileID, id)
+    options.responseType = "buffer";
+
+    // 2.请求
+    let data = await openapi.doRequest(null, urlPath, options);
+
+    // 3.写入文件
+    data = Buffer.from(data, 'binary');
+    if (filePath) {
+        checkUtils.checkFile(filePath);
+        utils.mkdirs(path.dirname(filePath));
+        fs.writeFileSync(filePath, data);
+        return;
+    }
+
+    return data;
+}
+
+async function downloadFileByToken(fileToken: string, filePath?: string): Promise<Buffer | void> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.downloadAttachment);
+    let urlPath = options._reqPath + `?token=${fileToken}`;
+    options.responseType = "buffer";
+
+    // 2.请求
+    let data = await openapi.doRequest(null, urlPath, options);
+
+    // 3.写入文件
+    data = Buffer.from(data, 'binary');
+    if (filePath) {
+        checkUtils.checkFile(filePath);
+        utils.mkdirs(path.dirname(filePath));
+        fs.writeFileSync(filePath, data);
+        return;
+    }
+
+    return data;
+}
+
+async function mGetFileToken(ids: string[]): Promise<Record<string, string>> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, coreOapiHttpPath.getBatchAttachmentToken);
+    let urlPath = options._reqPath;
+
+    // 2.请求
+    options.json = {
+        attachmentIds: ids
+    }
+    return await openapi.doRequest(null, urlPath, options);
+}
+
+async function createMessage(msg: any): Promise<number> {
+    // 1.解析参数 icon/receiverIds/percent
+    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: Record<string, any> = {"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["percent"] = JSON.stringify(percent);
+        }
+    }
+
+    // kunlun类型
+    if (checkUtils.isObject(msg)) {
+        for (let key of Object.keys(msg)) {
+            if (fieldType.isKFieldType(msg[key])) {
+                // instanceof 改动6
+                // if (msg[key] instanceof fieldType.Multilingual) {
+                if (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.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.createMessage);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK())
+
+    // 3.请求
+    options.json = {
+        "NotifyModelKey": notifyModel.key,
+        "ReceiverIDs": receiverIds,
+        "ParamsRawData": params,
+        "Percent": percent,
+        "ModelKeySearchData": modelKeySearchData
+    }
+
+    let res = await openapi.doRequest(null, urlPath, options);
+    return Number((res as any).taskID);
+}
+
+async function updateMessage(msgId: number, msg: any): Promise<void> {
+    // 1.解析参数 msgId/icon/percent
+    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: Record<string, any> = {};
+    let modelKeySearchData: Record<string, any> = {"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["percent"] = JSON.stringify(percent);
+        }
+    }
+
+    // kunlun类型
+    if (checkUtils.isObject(msg)) {
+        for (let key of Object.keys(msg)) {
+            if (fieldType.isKFieldType(msg[key])) {
+                // instanceof 改动7
+                // if (msg[key] instanceof fieldType.Multilingual) {
+                if (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.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.updateMessage);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK())
+
+    // 3.请求
+    options.json = {
+        "TaskID": msgId,
+        "Percent": percent,
+        "NotifyModelKey": notifyModel.key,
+        "ParamsRawData": params,
+        "IsBackground": true,
+        "ModelKeySearchData": modelKeySearchData
+    }
+
+    return await openapi.doRequest(null, urlPath, options);
+}
+
+async function getFields(objectApiName: string) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InvalidParamError("objectApiName is empty");
+    }
+
+    // 2.获取config
+    let options = commonHttp.getOptions(null, openapiHttpPath.getFieldsV5);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK())
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    let obj = await openapi.doRequest(null, urlPath, options)
+    if (!obj || !obj.fields) {
+        return [];
+    }
+
+    return obj.fields;
+}
+
+async function getField(objectApiName: string, fieldApiName: string) {
+    // 1.check
+    if (!objectApiName) {
+        throw new exceptions.InternalError("objectApiName is empty");
+    }
+    if (!fieldApiName) {
+        throw new exceptions.InternalError("fieldApiName is empty");
+    }
+
+    // 2.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.getFieldV5);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+    urlPath = urlPath.replace(replaceKeys.fieldApiName, fieldApiName);
+
+    // 3.请求
+    return await openapi.doRequest(null, urlPath, options)
+}
+
+async function terminateWorkflowInstance(workflowInstanceId: number, operator: number, reason: string) {
+    // 1.check
+    if (typeof (workflowInstanceId) !== "number") {
+        throw new exceptions.InvalidParamError(`The type of workflowInstanceId should be number, but ${typeof (workflowInstanceId)}.`);
+    }
+
+    // 2.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.terminateWorkflowInstance);
+    let urlPath = options._reqPath;
+
+    // 3.请求
+    options.json = {
+        "workflowInstanceID": workflowInstanceId,
+        "operator": operator,
+        "reason": reason,
+    }
+
+    await openapi.doRequest(null, urlPath, options);
+}
+
+async function modifyRecordsWithTransaction(placeholders: Record<string, number>, operations: object[]): Promise<Map<string, number>> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.modifyRecordsWithTransaction);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    // 2.请求
+    options.json = {
+        "placeholders": placeholders,
+        "operations": operations,
+        "operatorId": -1,
+    }
+
+    let taskId = utils.getTriggerTaskID();
+    if (taskId) {
+        options.json["taskId"] = taskId;
+    }
+
+    let result = await openapi.doRequest(null, urlPath, options);
+    let retPlaceholders = new Map<string, number>();
+    if (result && result.placeholders) {
+        for (let key of Object.keys(result.placeholders)) {
+            retPlaceholders.set(key, result.placeholders[key]);
+        }
+    }
+    return retPlaceholders
+};
+
+async function getGlobalConfigByKey<valueT>(key: string): Promise<valueT> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.getAllGlobalConfigs);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    // 2.请求
+    let pageSize = 100, offset = 0;
+    for (let i = 0; ; i++) {
+        options.json = {
+            "biz_type": "GlobalVariables",
+            "used_by": "UsedBySystem",
+            "filter": {
+                "offset": offset * i,
+                "limit": pageSize
+            },
+        }
+
+        let data = await openapi.doRequest(null, urlPath, options);
+        for (let config of data.configs) {
+            if (config.key === key) {
+                return config.value;
+            }
+        }
+
+        if (data.configs.length < pageSize) {
+            break;
+        }
+    }
+
+    throw new exceptions.InvalidParamError(`undefined global variable (${key})`);
+}
+
+
+async function oql(oql: string, args: any[], namedArgs: Record<string, any>) {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, coreOapiHttpPath.oql);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    // 2.请求
+    options.json = {
+        "query": oql,
+        "args": args,
+        "namedArgs": namedArgs,
+        "compat": true,
+    }
+
+    let result = await openapi.doRequest(null, urlPath, options);
+    if (result && result.rows) {
+        return result.rows;
+    }
+
+    return [];
+}
+
+async function openSDKCreateRecordBySync(objectApiName: string, record: object): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKCreateRecord);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = record;
+
+    return await openapi.doRequest(null, urlPath, options);
+};
+
+async function openSDKUpdateRecordBySync(objectApiName: string, recordID: number, record: object): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKUpdateRecord);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+    urlPath = urlPath.replace(replaceKeys.recordID, recordID.toString());
+
+    // 2.请求
+    options.json = record;
+
+    return await openapi.doRequest(null, urlPath, options);
+};
+
+async function openSDKDeleteRecordBySync(objectApiName: string, recordID: number): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKDeleteRecord);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+    urlPath = urlPath.replace(replaceKeys.recordID, recordID.toString());
+
+    // 2.请求
+    return await openapi.doRequest(null, urlPath, options);
+};
+
+async function openSDKCreateRecordsBySync(objectApiName: string, records: object[]): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKBatchCreateRecord);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = records;
+
+    return await openapi.doRequest(null, urlPath, options);
+};
+
+async function openSDKUpdateRecordsBySync(objectApiName: string, records: object[]): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKBatchUpdateRecord);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = records;
+
+    return await openapi.doRequest(null, urlPath, options);
+};
+
+async function openSDKDeleteRecordsBySync(objectApiName: string, recordIDs: number[]): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKBatchDeleteRecord);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    // 2.请求
+    options.json = recordIDs;
+
+    return await openapi.doRequest(null, urlPath, options);
+};
+
+async function openSDKGetRecords(objectApiName: string, param: OpenSDKGetRecordsReq): Promise<any | number> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKGetRecords);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.objectApiName, objectApiName);
+
+    if (param.limit <= 0 || param.limit > 200) {
+        param.limit = 200;
+    }
+
+    // 2.请求
+    options.json = param;
+
+    const data = await openapi.doRequest(null, urlPath, options);
+    if (param.count) {
+        return JSON.parse(data.records);
+    } else {
+        return data.total;
+    }
+}
+
+async function openSDKUploadFile(fileName: string, data: Buffer): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKUploadFile);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    let formData = new FormData();
+    formData.append('file', data);
+    formData.append('ignoreUserId', 'true');
+    let formHeaders = formData.getHeaders();
+
+    options.responseType = 'buffer';
+    for (let key of Object.keys(formHeaders)) {
+        options.headers[key] = formHeaders[key];
+    }
+    options.body = formData;
+
+    // 2.请求
+    return await openapi.doRequest(null, urlPath, options);
+}
+
+async function openSDKUploadAvatar(fileName: string, data: Buffer): Promise<any> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKUploadAvatar);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    let formData = new FormData();
+    formData.append('file', data);
+    formData.append('ignoreUserId', 'true');
+    let formHeaders = formData.getHeaders();
+
+    options.responseType = 'buffer';
+    for (let key of Object.keys(formHeaders)) {
+        options.headers[key] = formHeaders[key];
+    }
+    options.body = formData;
+
+    // 2.请求
+    return await openapi.doRequest(null, urlPath, options);
+
+}
+
+async function openSDKDownloadAvatar(imageID: string): Promise<Buffer> {
+    // 1.获取 options
+    let options = commonHttp.getOptions(null, openapiHttpPath.openSDKDownloadAvatar);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.fileID, imageID);
+
+    // 2.请求
+    let data = await openapi.doRequest(null, urlPath, options);
+
+    // 3.写入文件
+    data = Buffer.from(data, 'binary');
+
+    return data;
+}
+
+export class RequestHttp 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;
+        // TODO: open sdk api test
+        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;
+    }
+
+    updateWorkflowVariables(ctx: any, instanceId: number, variables: object, variableTypes: object): any {
+    }
+
+    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 {
+    }
+
+    uploadFile(data: Stream, expire: number): Promise<UploadFileResp> {
+        return null;
+    }
+
+    downloadFileByID(fileID: string, filePath?: string): Promise<void | Buffer> {
+        return null;
+    }
+
+    downloadFileByToken(fileToken: string, filePath?: string): Promise<Buffer | void> {
+        return null;
+    }
+
+    createMessage(msg: any): Promise<number> {
+        return null;
+    }
+
+    updateMessage(msgId: number, msg: any): Promise<void> {
+        return null;
+    }
+
+    getFields(objectApiName: string): any {
+    }
+
+    getField(objectApiName: string, fieldApiName: string): any {
+    }
+
+    terminateWorkflowInstance(workflowInstanceId: number, operator: number, reason: string): any {
+    }
+
+    modifyRecordsWithTransaction(placeholders: Record<string, number>, operations: object[]): Promise<Map<string, number>> {
+        return null;
+    }
+
+    getGlobalConfigByKey<valueT>(key: string): Promise<valueT> {
+        return null;
+    }
+
+    oql(oql: string, args: any[], namedArgs: Record<string, any>): any {
+    }
+
+    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): Promise<any | number> {
+        return null;
+    };
+
+    openSDKUploadFile(fileName: string, data: Buffer): any {
+    };
+
+    openSDKUploadAvatar(fileName: string, data: Buffer): any {
+    };
+
+    openSDKDownloadAvatar(imageID: string): Promise<Buffer> {
+        return null
+    };
+}
+
+async function invokeFuncWithAuth(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+    let options = commonHttp.getOptions(null, openapiHttpPath.invokeFuncWithAuthInnerAPI);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+    urlPath = urlPath.replace(replaceKeys.apiName, idOrName.APIName);
+
+    options.headers["User"] = utils.getUserIDFromCtx();
+
+    options.json = {
+        "params": params,
+        "context": getTriggerCtx(),
+    }
+
+    if (!idOrName.isInvokeByAPIName) {
+        options.json.apiID = idOrName.APIId;
+    }
+
+    let res = await openapi.doRequest(null, urlPath, options);
+
+    if (!res || !res.result) {
+        throw new exceptions.InternalError(`result is empty`)
+    }
+
+    let result: { code: string, msg: string, data: any; };
+    try {
+        result = JSON.parse(res.result);
+    } catch (e) {
+        throw new exceptions.InternalError(`JSON parse failed for ${res.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 invokeFuncSync(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+
+    let options = commonHttp.getOptions(null, openapiHttpPath.invokeFuncSyncInnerAPI);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    options.headers["User"] = utils.getUserIDFromCtx();
+
+    options.json = {
+        "params": JSON.stringify(params),
+        "context": JSON.stringify(getTriggerCtx()),
+        "triggerType": utils.getTriggerType(),
+    }
+
+    //  相等时，表示是新版本函数的场景
+    if (idOrName.isInvokeByAPIName) {
+        options.json.apiAlias = idOrName.APIName;
+        options.json.function_name = "";
+    } else {
+        options.json.function_name = idOrName.APIId;
+        options.json.apiAlias = "";
+    }
+
+    let res = await openapi.doRequest(null, urlPath, options);
+    if (res && res.code === "0") {
+        return res.data;
+    }
+    throw new exceptions.InternalError(`invokeFuncSync result.code(${res.code}) is invalid`)
+}
+
+async function createAsyncTaskV1(idOrName: { APIId?: string; APIName?: string; isInvokeByAPIName: boolean }, params: any): Promise<any> {
+
+    let options = commonHttp.getOptions(null, openapiHttpPath.createAsyncTaskInnerAPIV1);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    options.headers["User"] = utils.getUserIDFromCtx();
+
+    options.json = {
+        "params": JSON.stringify(params),
+        "context": JSON.stringify(getTriggerCtx()),
+        "triggerType": utils.getTriggerType(),
+    }
+
+    //  相等时，表示是新版本函数的场景
+    if (idOrName.isInvokeByAPIName) {
+        options.json.apiAlias = idOrName.APIName;
+        options.json.function_name = ""; // required
+    } else {
+        options.json.function_name = idOrName.APIId;
+    }
+
+    let res = await openapi.doRequest(null, urlPath, options);
+    if (res && res.task_id) {
+        return res.task_id;
+    }
+    throw new exceptions.InternalError(`createAsyncTaskV1 result is empty`)
+}
+
+async function createAsyncTaskV2(APIName: string, params: any): Promise<any> {
+
+    let options = commonHttp.getOptions(null, openapiHttpPath.createAsyncTaskInnerAPIV2);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK());
+
+    let triggerCtx: Record<string, any> = {}, taskID = utils.getTriggerTaskID();
+    if (taskID) {
+        triggerCtx[headers.triggerTaskId] = taskID;
+    }
+
+    let temp = utils.getDistributedHandleMask();
+    if (temp) {
+        triggerCtx[headers.distributedHandleMask] = temp;
+    }
+
+    let reqCtx = nodeCls.get(headers.loopCtxKey);
+    if (checkLoopCtx(reqCtx)) {
+        triggerCtx[headers.loopMasks] = reqCtx.loopMasks
+    }
+
+    options.headers["User"] = utils.getUserIDFromCtx();
+
+    options.json = {
+        "apiAlias": APIName,
+        "params": JSON.stringify(params),
+        "context": JSON.stringify(getTriggerCtx()),
+        "triggerType": utils.getTriggerType(),
+        "extra": getDebugExtraInfo()
+    }
+
+    let res = await openapi.doRequest(null, urlPath, options);
+    if (res && res.task_id) {
+        return res.task_id;
+    }
+    throw new exceptions.InternalError(`createAsyncTaskV2 result is empty`)
+}
+
+function checkLoopCtx(reqCtx: any): any {
+    return reqCtx && reqCtx.loopMasks && Array.isArray(reqCtx.loopMasks)
+}
+
+
+function getTriggerCtx(): any {
+    let triggerCtx: Record<string, any> = {}, taskID = utils.getTriggerTaskID();
+    if (taskID) {
+        triggerCtx[headers.triggerTaskId] = taskID;
+    }
+
+    let temp = utils.getDistributedHandleMask();
+    if (temp) {
+        triggerCtx[headers.distributedHandleMask] = temp;
+    }
+
+    let reqCtx = nodeCls.get(headers.loopCtxKey);
+    if (checkLoopCtx(reqCtx)) {
+        triggerCtx[headers.loopMasks] = reqCtx.loopMasks
+    }
+    return triggerCtx;
+}
+
+export async function getExecutionUserTaskInfo(executionId: bigint): Promise<any> {
+    if (!executionId) {
+        throw new exceptions.InvalidParamError(`executionId is empty`);
+    }
+
+    let options = commonHttp.getOptions(null, coreOapiHttpPath.getExecutionUserTaskInfo);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK()).replace(replaceKeys.id, `${executionId}`);
+    urlPath += `?operator=${utils.getUserIDFromCtx()}`
+
+    let res = await openapi.doRequest(null, urlPath, options);
+
+    if (!res) {
+        throw new exceptions.InternalError(`getExecutionUserTaskInfo result is empty`);
+    }
+
+    return res.taskList;
+}
+
+export async function executeFlow(APIName: string, option: any): Promise<ExecutionResult> {
+    if (!APIName) {
+        throw new exceptions.InvalidParamError(`flow apiName is empty`);
+    }
+
+    let options = commonHttp.getOptions(null, coreOapiHttpPath.executeFlow);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK()).replace(replaceKeys.apiName, APIName);
+
+    options.json = {
+        "operator": utils.getUserIDFromCtx(),
+        "variables": transMapToFlowVariable(option.params),
+        "loopMasks": utils.getLoopMasks(),
+    }
+    let res = await openapi.doRequest(null, urlPath, options);
+    return {
+        executionId: res.executionId,
+        status: res.status,
+        data: transFlowVariableToMap(res.outParams),
+        errCode: res.errCode ? res.errCode : undefined,
+        errMsg: res.errMsg ? res.errMsg : undefined,
+    };
+}
+
+export async function revokeExecution(executionId: number, revokeOptions: RevokeExecutionOptions): Promise<void> {
+    if (!executionId) {
+        throw new exceptions.InvalidParamError(`executionId is empty`);
+    }
+    let options = commonHttp.getOptions(null, coreOapiHttpPath.revokeExecution);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK()).replace(replaceKeys.id, `${executionId}`);
+
+    let reason: { en_US?: string, zh_CN?: string } = undefined;
+
+    if (revokeOptions && revokeOptions.reason) {
+        reason = {
+            en_US: revokeOptions.reason.en_US,
+            zh_CN: revokeOptions.reason.zh_CN
+        }
+    }
+
+    options.json = {
+        "operator": utils.getUserIDFromCtx(),
+        "reason": reason,
+    };
+
+    return await openapi.doRequest(null, urlPath, options);
+}
+
+export async function getExecutionInfo(executionId: number): Promise<ExecutionInfo> {
+    if (!executionId) {
+        throw new exceptions.InvalidParamError(`executionId is empty`);
+    }
+
+    let options = commonHttp.getOptions(null, coreOapiHttpPath.getExecutionInfo);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, await getNamespaceForOpenAndFaaSSDK()).replace(replaceKeys.id, `${executionId}`);
+    urlPath += `?operator=${utils.getUserIDFromCtx()}`
+
+    let res = await openapi.doRequest(null, urlPath, options);
+
+    if (!res || !res.executionInfo) {
+        throw new exceptions.InternalError(`getExecutionInfo result is empty`);
+    }
+
+    return {
+        status: res.executionInfo.status,
+        data: transFlowVariableToMap(res.executionInfo.outParams),
+        errCode: res.executionInfo.errCode ? res.executionInfo.errCode : undefined,
+        errMsg: res.executionInfo.errMsg ? res.executionInfo.errMsg : undefined,
+    };
+}