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

package/request/common.ts

@@ -0,0 +1,91 @@
+import {headers} from "@byted-apaas/server-common-node/constants/constants";
+import * as common from "@byted-apaas/server-common-node";
+import {GetInstance} from "./interface";
+import {AppCtx} from "../application/application";
+import {AppCredential} from "@byted-apaas/server-common-node/credential/credential";
+import {InvalidParamError} from "@byted-apaas/server-common-node/utils/exceptions";
+import {runCtxForOpenSDK} from "../application/impl/common";
+
+const utils = common.utils;
+const checkUtils = common.checkUtils;
+const exceptions = common.exceptions;
+const nodeCls = require("node-cls");
+
+
+function checkLoopCtx(reqCtx: any): any {
+    return reqCtx && reqCtx.loopMasks && Array.isArray(reqCtx.loopMasks)
+}
+
+export function getDebugExtraInfo() {
+    let extra: Record<string, string> = {
+        "FunctionFrameVersion": "FunctionFrameV2",
+    };
+    if (utils.isDebug()) {
+        extra.DebugInfo = utils.getDebugCode();
+    }
+
+    return extra
+}
+
+export 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 function transMapToFlowVariable(params: Record<string, any>): { api_name: string, value: any }[] {
+    let variables: { api_name: string, value: any }[] = [];
+    if (params) {
+        if (checkUtils.isNotObject(params)) {
+            throw new exceptions.InvalidParamError(`params should be object, and not array`);
+        }
+        for (const [k, v] of Object.entries(params)) {
+            variables.push({api_name: k, value: v});
+        }
+    }
+    return variables;
+}
+
+export function transFlowVariableToMap(variables: { api_name: string, value: any }[]): Record<string, any> {
+    let data: Record<string, any> = {};
+    if (variables && Array.isArray(variables)) {
+        for (const o of variables) {
+            data[o.api_name] = o.value
+        }
+    }
+    return data;
+}
+
+export async function getTenantInfo(appCtx: AppCtx): Promise<any> {
+    if (!appCtx) {
+        appCtx = {
+            mode: "faasSDK",
+            credential: new AppCredential(utils.getClientId(), utils.getClientSecret(), true)
+        }
+    }
+    if (!appCtx.credential) {
+        throw new InvalidParamError(`credential is empty`)
+    }
+    return await runCtxForOpenSDK(appCtx, async () => {
+        return await GetInstance().getTenantInfo(appCtx);
+    });
+}
+
+export async function getNamespaceForOpenAndFaaSSDK(): Promise<string> {
+    if (utils.isOpenSDKMode()) { // TODO check need assign?
+        return (await utils.getCredential().getTenantInfo()).namespace;
+    }
+    return utils.getNamespaceFromCtx();
+}

package/request/constants.d.ts

@@ -0,0 +1,10 @@
+import { GetHttpConfig, PostHttpConfig } from "@byted-apaas/server-common-node/http/config";
+export declare const metricsMethodKeys: Record<string, string>;
+export declare const openapiHttpPath: {
+    getBatchAttachmentToken: PostHttpConfig;
+    oql: PostHttpConfig;
+    getExecutionUserTaskInfo: GetHttpConfig;
+    executeFlow: PostHttpConfig;
+    revokeExecution: PostHttpConfig;
+    getExecutionInfo: GetHttpConfig;
+};

package/request/constants.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openapiHttpPath = exports.metricsMethodKeys = void 0;
+const config_1 = require("@byted-apaas/server-common-node/http/config");
+const constants_1 = require("@byted-apaas/server-common-node/http/constants");
+exports.metricsMethodKeys = {
+    // openapi
+    // file upload & download
+    getBatchAttachmentToken: "openapi_getBatchAttachmentToken",
+    oql: "openapi_oql",
+    // flow
+    getExecutionUserTaskInfo: "openapi_getExecutionUserTaskInfo",
+    getExecutionInfo: "openapi_getExecutionInfo",
+    revokeExecution: "openapi_revokeExecution",
+    executeFlow: "openapi_executeFlow",
+};
+exports.openapiHttpPath = {
+    getBatchAttachmentToken: new config_1.PostHttpConfig(`/attachment/v1/getBatchAttachmentToken`, exports.metricsMethodKeys.getBatchAttachmentToken),
+    oql: new config_1.PostHttpConfig(`/data/v5/namespaces/${constants_1.replaceKeys.namespace}/records/query`, exports.metricsMethodKeys.oql),
+    // flow
+    getExecutionUserTaskInfo: new config_1.GetHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/executions/${constants_1.replaceKeys.id}/userTaskInfo`, exports.metricsMethodKeys.getExecutionUserTaskInfo),
+    executeFlow: new config_1.PostHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/flows/${constants_1.replaceKeys.apiName}/execute`, exports.metricsMethodKeys.executeFlow),
+    revokeExecution: new config_1.PostHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/executions/${constants_1.replaceKeys.id}/revoke`, exports.metricsMethodKeys.revokeExecution),
+    getExecutionInfo: new config_1.GetHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/executions/${constants_1.replaceKeys.id}/detail`, exports.metricsMethodKeys.getExecutionInfo),
+};

package/request/constants.ts

@@ -0,0 +1,25 @@
+import {GetHttpConfig, PostHttpConfig} from "@byted-apaas/server-common-node/http/config";
+import {replaceKeys} from "@byted-apaas/server-common-node/http/constants";
+
+export const metricsMethodKeys: Record<string, string> = {
+    // openapi
+    // file upload & download
+    getBatchAttachmentToken: "openapi_getBatchAttachmentToken",
+    oql: "openapi_oql",
+    // flow
+    getExecutionUserTaskInfo: "openapi_getExecutionUserTaskInfo",
+    getExecutionInfo: "openapi_getExecutionInfo",
+    revokeExecution: "openapi_revokeExecution",
+    executeFlow: "openapi_executeFlow",
+}
+
+export const openapiHttpPath = {
+    getBatchAttachmentToken: new PostHttpConfig(`/attachment/v1/getBatchAttachmentToken`, metricsMethodKeys.getBatchAttachmentToken),
+    oql: new PostHttpConfig(`/data/v5/namespaces/${replaceKeys.namespace}/records/query`, metricsMethodKeys.oql),
+
+    // flow
+    getExecutionUserTaskInfo: new GetHttpConfig(`/api/flow/v1/namespaces/${replaceKeys.namespace}/executions/${replaceKeys.id}/userTaskInfo`, metricsMethodKeys.getExecutionUserTaskInfo),
+    executeFlow: new PostHttpConfig(`/api/flow/v1/namespaces/${replaceKeys.namespace}/flows/${replaceKeys.apiName}/execute`, metricsMethodKeys.executeFlow),
+    revokeExecution: new PostHttpConfig(`/api/flow/v1/namespaces/${replaceKeys.namespace}/executions/${replaceKeys.id}/revoke`, metricsMethodKeys.revokeExecution),
+    getExecutionInfo: new GetHttpConfig(`/api/flow/v1/namespaces/${replaceKeys.namespace}/executions/${replaceKeys.id}/detail`, metricsMethodKeys.getExecutionInfo),
+}

package/request/faasinfra.d.ts

@@ -0,0 +1,8 @@
+import { IFaaSInfraRequest } from "./interface";
+export declare class FaaSInfraRequest implements IFaaSInfraRequest {
+    constructor();
+    createDistributeTaskV1(dataset: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: any): Promise<any>;
+    createDistributeTaskV2(dataset: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: any): Promise<any>;
+    invokeMicroserviceSync(apiName: string, path: string, method: string, body: any): Promise<any>;
+    invokeMicroserviceAsync(apiName: string, path: string, method: string, body: any): Promise<any>;
+}

package/request/faasinfra.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaaSInfraRequest = void 0;
+const common = require("@byted-apaas/server-common-node");
+const headers = common.constants.headers;
+const commonHttp = common.http;
+const faasinfra = common.http.faasinfra;
+const faasinfraHttpPath = common.http.faasinfraHttpPath;
+const replaceKeys = common.http.replaceKeys;
+const exceptions = common.exceptions;
+const utils = common.utils;
+const nodeCls = require("node-cls");
+const distributedHandleMask = headers.distributedHandleMask;
+const loopMasks = headers.loopMasks;
+const loopMasksKey = headers.loopMasksKey;
+const loopCtxKey = headers.loopCtxKey;
+const url_1 = require("url");
+const exceptions_1 = require("@byted-apaas/server-common-node/utils/exceptions");
+class FaaSInfraRequest {
+    constructor() {
+    }
+    async createDistributeTaskV1(dataset, handlerFunc, progressCallbackFunc, completedCallbackFunc, options) {
+        // 1.获取 options
+        let config = commonHttp.getOptions(null, faasinfraHttpPath.createDistributedTask);
+        // 2.构造url
+        let urlPath = config._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+        // 3.请求
+        config.json = {
+            "domainName": utils.getTenantNameFromCtx(),
+            "namespace": utils.getNamespaceFromCtx(),
+            "userId": utils.getUserIDFromCtx(),
+            "dataset": dataset,
+            "handlerFunc": handlerFunc,
+            "progressCallbackFunc": progressCallbackFunc,
+            "completedCallbackFunc": completedCallbackFunc,
+            "options": options
+        };
+        let task_id = utils.getTriggerTaskID();
+        if (task_id) {
+            config.json[headers.triggerTaskId] = task_id;
+        }
+        let loopCtx = nodeCls.get(loopCtxKey);
+        if (checkLoopCtx(loopCtx)) {
+            config.json[loopMasksKey] = loopCtx.loopMasks;
+            if (!utils.isMicroservice() && (handlerFunc !== "" && config.json[loopMasksKey].includes(utils.handleFuncName({}, handlerFunc))) ||
+                (progressCallbackFunc != "" && config.json[loopMasksKey].includes(utils.handleFuncName({}, progressCallbackFunc))) ||
+                (completedCallbackFunc != "" && config.json[loopMasksKey].includes(utils.handleFuncName({}, completedCallbackFunc)))) {
+                throw new exceptions.InvalidParamError(`Task execution forms a loop.`);
+            }
+        }
+        return await faasinfra.doRequest(null, urlPath, config);
+    }
+    async createDistributeTaskV2(dataset, handlerFunc, progressCallbackFunc, completedCallbackFunc, options) {
+        // 检查函数是否存在
+        utils.requireFunction(handlerFunc);
+        // 1.获取 options
+        let config = commonHttp.getOptions(null, faasinfraHttpPath.createDistributedTaskV2);
+        // 2.构造url
+        let urlPath = config._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+        // 3.请求
+        config.json = {
+            "domainName": utils.getTenantNameFromCtx(),
+            "namespace": utils.getNamespaceFromCtx(),
+            "userId": utils.getUserIDFromCtx(),
+            "dataset": dataset,
+            "handlerFunc": handlerFunc,
+            "progressCallbackFunc": progressCallbackFunc,
+            "completedCallbackFunc": completedCallbackFunc,
+            "options": options,
+            "extra": getDebugExtraInfo()
+        };
+        let task_id = utils.getTriggerTaskID();
+        if (task_id) {
+            config.json[headers.triggerTaskId] = task_id;
+        }
+        let loopCtx = nodeCls.get(loopCtxKey);
+        if (checkLoopCtx(loopCtx)) {
+            config.json[loopMasksKey] = loopCtx.loopMasks;
+            if ((handlerFunc !== "" && config.json[loopMasksKey].includes(handlerFunc)) ||
+                (progressCallbackFunc != "" && config.json[loopMasksKey].includes(progressCallbackFunc)) ||
+                (completedCallbackFunc != "" && config.json[loopMasksKey].includes(completedCallbackFunc))) {
+                throw new exceptions.InvalidParamError(`Task execution forms a loop.`);
+            }
+        }
+        return await faasinfra.doRequest(null, urlPath, config);
+    }
+    async invokeMicroserviceSync(apiName, path, method, body) {
+        let reqPath = faasinfraHttpPath.invokeMicroserviceSync;
+        let options = commonHttp.getOptions(null, reqPath);
+        let urlPath = options._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+        options.json = {
+            "microserviceId": apiName,
+            "path": path,
+            "method": method,
+            "query": parseQueryParams(path),
+        };
+        // 处理 body 参数
+        if (method.toUpperCase() !== "GET") {
+            options.json.body = JSON.stringify(body);
+        }
+        return await faasinfra.doRequest(null, urlPath, options);
+    }
+    async invokeMicroserviceAsync(apiName, path, method, body) {
+        let reqPath = faasinfraHttpPath.invokeMicroserviceAsync;
+        let options = commonHttp.getOptions(null, reqPath);
+        let urlPath = options._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+        options.json = {
+            "microserviceId": apiName,
+            "path": path,
+            "method": method,
+            "query": parseQueryParams(path),
+        };
+        // 处理 body 参数
+        if (method.toUpperCase() !== "GET") {
+            options.json.body = JSON.stringify(body);
+        }
+        return await faasinfra.doRequest(null, urlPath, options);
+    }
+}
+exports.FaaSInfraRequest = FaaSInfraRequest;
+function getDebugExtraInfo() {
+    let extra = {
+        "FunctionFrameVersion": "FunctionFrameV2",
+    };
+    if (utils.isDebug()) {
+        extra.DebugInfo = utils.getDebugCode();
+    }
+    return extra;
+}
+function checkLoopCtx(reqCtx) {
+    return reqCtx && reqCtx.loopMasks && Array.isArray(reqCtx.loopMasks);
+}
+function parseQueryParams(path) {
+    let params = {};
+    let url = new url_1.URL(path, "https://aa.bb.cc");
+    for (let [k, v] of url.searchParams.entries()) {
+        if (typeof (k) !== "string") {
+            throw new exceptions_1.InternalError(`The type of k should be string, but ${typeof (k)}`);
+        }
+        if (typeof (v) !== "string") {
+            throw new exceptions_1.InternalError(`The type of v should be string, but ${typeof (v)}`);
+        }
+        params[k] = v.split(",");
+    }
+    if (Object.keys(params).length === 0) {
+        return undefined;
+    }
+    return params;
+}
+/*
+export async function invokeFuncSync(apiName: string, params: any, oldFuncName: string, isSync: boolean) {
+    let result = await invokeFunc(apiName, params, oldFuncName, isSync);
+    if (result && result.code === "0") {
+        return result.data;
+    }
+    return result;
+}
+
+async function invokeFunc(apiName: string, params: any, oldFuncName: string, isSync = false) {
+    let reqPath = faasinfraHttpPath.createAsyncTask;
+    if (isSync) {
+        reqPath = faasinfraHttpPath.invokeFuncSync;
+    }
+
+    let options = commonHttp.getOptions(null, reqPath);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+
+    let triggerCtx: Record<string, any> = {};
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        triggerCtx[headers.triggerTaskId] = task_id;
+    }
+
+    let temp = utils.getDistributedHandleMask();
+    if (temp) {
+        triggerCtx[distributedHandleMask] = temp;
+    }
+
+    let reqCtx = nodeCls.get(loopCtxKey);
+    if (checkLoopCtx(reqCtx)) {
+        triggerCtx[loopMasks] = reqCtx.loopMasks
+    }
+
+    //  相等时，表示是新版本函数的场景
+    if (apiName === oldFuncName) {
+        options.json = {
+            "apiAlias": apiName,
+            "params": JSON.stringify(params),
+            "context": JSON.stringify(triggerCtx),
+            "triggerType": utils.getTriggerType(),
+        }
+    } else {
+        options.json = {
+            "function_name": apiName,
+            "params": JSON.stringify(params),
+            "context": JSON.stringify(triggerCtx),
+            "triggerType": utils.getTriggerType(),
+        }
+    }
+
+    if (utils.isMicroservice()) {
+        options.json.apiAlias = oldFuncName;
+    }
+
+    return await faasinfra.doRequest(null, urlPath, options);
+}
+
+export async function asyncTask(apiName: string, params: any) {
+    // 检查函数是否存在
+    utils.requireFunction(apiName);
+
+    let reqPath = faasinfraHttpPath.createAsyncTaskV2;
+    let options = commonHttp.getOptions(null, reqPath);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+
+    let triggerCtx: Record<string, any> = {};
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        triggerCtx[headers.triggerTaskId] = task_id;
+    }
+
+    let temp = utils.getDistributedHandleMask();
+    if (temp) {
+        triggerCtx[distributedHandleMask] = temp;
+    }
+
+    let reqCtx = nodeCls.get(loopCtxKey);
+    if (checkLoopCtx(reqCtx)) {
+        triggerCtx[loopMasks] = reqCtx.loopMasks
+    }
+
+    options.json = {
+        "api_name": apiName,
+        "params": JSON.stringify(params),
+        "context": JSON.stringify(triggerCtx),
+        "triggerType": utils.getTriggerType(),
+        "extra": getDebugExtraInfo()
+    }
+
+    return await faasinfra.doRequest(null, urlPath, options);
+}
+
+export async function createDistributedTaskV1(dataset: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: _Options):
+    Promise<number> {
+    // 1.获取 options
+    let config = commonHttp.getOptions(null, faasinfraHttpPath.createDistributedTask);
+
+    // 2.构造url
+    let urlPath = config._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+
+    // 3.请求
+    config.json = {
+        "domainName": utils.getTenantNameFromCtx(),
+        "namespace": utils.getNamespaceFromCtx(),
+        "userId": utils.getUserIDFromCtx(),
+
+        "dataset": dataset,
+        "handlerFunc": handlerFunc,
+        "progressCallbackFunc": progressCallbackFunc,
+        "completedCallbackFunc": completedCallbackFunc,
+        "options": options
+    }
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        config.json[headers.triggerTaskId] = task_id;
+    }
+
+    let loopCtx = nodeCls.get(loopCtxKey);
+    if (checkLoopCtx(loopCtx)) {
+        config.json[loopMasksKey] = loopCtx.loopMasks;
+        if (!utils.isMicroservice() && (handlerFunc !== "" && config.json[loopMasksKey].includes(utils.handleFuncName({}, handlerFunc))) ||
+            (progressCallbackFunc != "" && config.json[loopMasksKey].includes(utils.handleFuncName({}, progressCallbackFunc))) ||
+            (completedCallbackFunc != "" && config.json[loopMasksKey].includes(utils.handleFuncName({}, completedCallbackFunc)))) {
+            throw new exceptions.InvalidParamError(`Task execution forms a loop.`);
+        }
+    }
+
+    return await faasinfra.doRequest(null, urlPath, config);
+}
+
+export async function createDistributedTask(dataset: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: _Options): Promise<number> {
+    if (utils.isOnlineDev()) {
+        return await createDistributedTaskV1(dataset, handlerFunc, progressCallbackFunc, completedCallbackFunc, options);
+    }
+    // 检查函数是否存在
+    utils.requireFunction(handlerFunc);
+
+    // 1.获取 options
+    let config = commonHttp.getOptions(null, faasinfraHttpPath.createDistributedTaskV2);
+
+    // 2.构造url
+    let urlPath = config._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+
+    // 3.请求
+    config.json = {
+        "domainName": utils.getTenantNameFromCtx(),
+        "namespace": utils.getNamespaceFromCtx(),
+        "userId": utils.getUserIDFromCtx(),
+
+        "dataset": dataset,
+        "handlerFunc": handlerFunc,
+        "progressCallbackFunc": progressCallbackFunc,
+        "completedCallbackFunc": completedCallbackFunc,
+        "options": options,
+        "extra": getDebugExtraInfo()
+    }
+
+    let task_id = utils.getTriggerTaskID();
+    if (task_id) {
+        config.json[headers.triggerTaskId] = task_id;
+    }
+
+    let loopCtx = nodeCls.get(loopCtxKey);
+    if (checkLoopCtx(loopCtx)) {
+        config.json[loopMasksKey] = loopCtx.loopMasks;
+        if ((handlerFunc !== "" && config.json[loopMasksKey].includes(handlerFunc)) ||
+            (progressCallbackFunc != "" && config.json[loopMasksKey].includes(progressCallbackFunc)) ||
+            (completedCallbackFunc != "" && config.json[loopMasksKey].includes(completedCallbackFunc))) {
+            throw new exceptions.InvalidParamError(`Task execution forms a loop.`);
+        }
+    }
+
+    return await faasinfra.doRequest(null, urlPath, config);
+}
+
+export async function invokeMicroserviceSync(apiName: string, path: string, method: string, body: any) {
+    return await invokeMicroservice(apiName, path, method, body, true);
+}
+
+export async function invokeMicroserviceAsync(apiName: string, path: string, method: string, body: any) {
+    return await invokeMicroservice(apiName, path, method, body, false);
+}
+
+async function invokeMicroservice(apiName: string, path: string, method: string, body: any, isSync = false) {
+    let reqPath = faasinfraHttpPath.invokeMicroserviceAsync;
+    if (isSync) {
+        reqPath = faasinfraHttpPath.invokeMicroserviceSync;
+    }
+
+    let options = commonHttp.getOptions(null, reqPath);
+    let urlPath = options._reqPath.replace(replaceKeys.namespace, utils.getNamespaceFromCtx());
+
+    options.json = {
+        "microserviceId": apiName,
+        "path": path,
+        "method": method,
+        "query": parseQueryParams(path),
+    }
+
+    // 处理 body 参数
+    if (method.toUpperCase() !== "GET") {
+        options.json.body = JSON.stringify(body);
+    }
+
+    return await faasinfra.doRequest(null, urlPath, options);
+}
+*/