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

package/request/faasinfra.ts

@@ -0,0 +1,393 @@
+import * as common from "@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;
+
+import {URL} from "url";
+import {InternalError} from "@byted-apaas/server-common-node/utils/exceptions";
+import {IFaaSInfraRequest} from "./interface";
+
+export class FaaSInfraRequest implements IFaaSInfraRequest {
+    constructor() {
+    }
+
+    async createDistributeTaskV1(dataset: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: any): Promise<any> {
+        // 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: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: any): Promise<any> {
+        // 检查函数是否存在
+        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: string, path: string, method: string, body: any): Promise<any> {
+        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: string, path: string, method: string, body: any): Promise<any> {
+        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);
+    }
+
+}
+
+
+function getDebugExtraInfo() {
+    let extra: Record<string, string> = {
+        "FunctionFrameVersion": "FunctionFrameV2",
+    };
+    if (utils.isDebug()) {
+        extra.DebugInfo = utils.getDebugCode();
+    }
+
+    return extra
+}
+
+function checkLoopCtx(reqCtx: any): any {
+    return reqCtx && reqCtx.loopMasks && Array.isArray(reqCtx.loopMasks)
+}
+
+function parseQueryParams(path: string): Record<string, string[]> {
+    let params: Record<string, string[]> = {};
+
+    let url = new URL(path, "https://aa.bb.cc");
+    for (let [k, v] of url.searchParams.entries()) {
+        if (typeof (k) !== "string") {
+            throw new InternalError(`The type of k should be string, but ${typeof (k)}`);
+        }
+        if (typeof (v) !== "string") {
+            throw new 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);
+}
+*/

package/request/innerapi.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+/// <reference types="node" />
+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 { ExecutionInfo, ExecutionResult, RevokeExecutionOptions } from "@byted-apaas/server-common-node/context/workflow/workflow";
+import { AppCtx } from "../application/application";
+export declare class RequestRpc implements IInnerAPIRequest {
+    constructor();
+    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;
+    updateWorkflowVariables(ctx: any, instanceId: number, variables: object, variableTypes: object): Promise<void>;
+    uploadFile(data: Stream, expire: number): Promise<UploadFileResp>;
+    downloadFileByID(fileID: string, filePath?: string): Promise<Buffer | void>;
+    downloadFileByToken(fileToken: string, filePath?: string): Promise<Buffer | void>;
+    createMessage(msg: any): Promise<number>;
+    updateMessage(msgId: number, msg: any): Promise<void>;
+    getFields(objectApiName: string): Promise<any>;
+    getField(objectApiName: string, fieldApiName: string): Promise<any>;
+    terminateWorkflowInstance(workflowInstanceId: number, operator: number, reason: string): Promise<void>;
+    modifyRecordsWithTransaction(placeholders: Record<string, number>, operations: object[]): Promise<Map<string, number>>;
+    getGlobalConfigByKey<valueT>(key: string): Promise<valueT>;
+    oql(oql: string, args: any[], namedArgs: Record<string, any>): Promise<string | any[]>;
+    invokeFuncSync(idOrName: {
+        APIId?: string;
+        APIName?: string;
+        isInvokeByAPIName: boolean;
+    }, params: any): Promise<any>;
+    invokeFuncWithAuth(idOrName: {
+        APIId?: string;
+        APIName?: string;
+        isInvokeByAPIName: boolean;
+    }, params: any): Promise<any>;
+    createAsyncTaskV1(idOrName: {
+        APIId?: string;
+        APIName?: string;
+        isInvokeByAPIName: boolean;
+    }, params: any): Promise<any>;
+    createAsyncTaskV2(name: string, params: any): Promise<any>;
+    getExecutionUserTaskInfo(executionId: bigint): Promise<any>;
+    executeFlow(APIName: string, options: any): Promise<ExecutionResult>;
+    revokeExecution(executionId: number, revokeOptions: RevokeExecutionOptions): Promise<void>;
+    getExecutionInfo(executionId: number): Promise<ExecutionInfo>;
+    getTenantInfo(appCtx: AppCtx): Promise<any>;
+    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): void;
+    openSDKUploadFile(fileName: string, data: Buffer): any;
+    openSDKUploadAvatar(fileName: string, data: Buffer): any;
+    openSDKDownloadAvatar(imageID: string): any;
+}
+export declare function revokeExecution(executionId: number, revokeOptions: RevokeExecutionOptions): Promise<void>;
+export declare function getExecutionInfo(executionId: number): Promise<ExecutionInfo>;
+export declare function getExecutionUserTaskInfo(executionId: bigint): Promise<any>;