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

package/context/resources/impl/resources.js

@@ -0,0 +1,150 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._Resources = exports._OpenSDKResources = exports._KunlunFile = exports._KunlunOpenSDKFile = void 0;
+const stream_1 = require("stream");
+const Request = require("../../../request/interface");
+const common_1 = require("../../../application/impl/common");
+const common = require("@byted-apaas/server-common-node");
+const stream_to_buffer_1 = require("@jorgeferrero/stream-to-buffer");
+const exceptions = common.exceptions;
+const fs = require('fs');
+class _KunlunOpenSDKFile {
+    constructor(appCtx) {
+        this.appCtx = appCtx;
+    }
+    async Upload(fileName, source) {
+        // 1. check parameters type
+        if (typeof fileName !== 'string') {
+            throw new exceptions.InvalidParamError('upload method parameter fileName must be string. ');
+        }
+        if (typeof source !== 'string' && !(source instanceof stream_1.Stream) && !(source instanceof Buffer)) {
+            throw new exceptions.InvalidParamError('upload method parameter source must be string or stream or buffer. ');
+        }
+        // 2. divide by source type
+        if (typeof source === 'string') {
+            // upload from path
+            if (!fs.existsSync(source)) {
+                throw new exceptions.InvalidParamError(`no such file '${source}'`);
+            }
+            source = fs.createReadStream(source);
+        }
+        if (source instanceof stream_1.Stream) {
+            // upload from stream
+            source = await (0, stream_to_buffer_1.streamToBuffer)(source);
+        }
+        if (source instanceof Buffer) {
+            return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+                return await Request.GetInstance().openSDKUploadFile(fileName, source);
+            });
+        }
+        return null;
+    }
+    ;
+    async UploadAvatar(fileName, source) {
+        // 1. check parameters type
+        if (typeof fileName !== 'string') {
+            throw new exceptions.InvalidParamError('upload method parameter fileName must be string. ');
+        }
+        if (typeof source !== 'string' && !(source instanceof stream_1.Stream) && !(source instanceof Buffer)) {
+            throw new exceptions.InvalidParamError('upload method parameter source must be string or stream or buffer. ');
+        }
+        // 2. divide by source type
+        if (typeof source === 'string') {
+            // upload from path
+            if (!fs.existsSync(source)) {
+                throw new exceptions.InvalidParamError(`no such file '${source}'`);
+            }
+            source = fs.createReadStream(source);
+        }
+        if (source instanceof stream_1.Stream) {
+            // upload from stream
+            source = await (0, stream_to_buffer_1.streamToBuffer)(source);
+        }
+        if (source instanceof Buffer) {
+            // upload from buffer
+            return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+                return await Request.GetInstance().openSDKUploadAvatar(fileName, source);
+            });
+        }
+        return null;
+    }
+    ;
+    async Download(fileID) {
+        // 1. check parameters type
+        if (typeof fileID !== 'string') {
+            throw new exceptions.InvalidParamError('download method parameter fileID must be string. ');
+        }
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().downloadFileByID(fileID);
+        });
+    }
+    ;
+    async DownloadAvatar(imageID) {
+        // 1. check parameters type
+        if (typeof imageID !== 'string') {
+            throw new exceptions.InvalidParamError('download method parameter imageID must be string. ');
+        }
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().openSDKDownloadAvatar(imageID);
+        });
+    }
+    ;
+}
+exports._KunlunOpenSDKFile = _KunlunOpenSDKFile;
+class _KunlunFile {
+    async download(fileTokenOrInfo, filePath) {
+        if (typeof (fileTokenOrInfo) === "string") {
+            return await Request.GetInstance().downloadFileByToken(fileTokenOrInfo, filePath);
+        }
+        else if (typeof (fileTokenOrInfo) === "object") {
+            if (!fileTokenOrInfo.id) {
+                throw new exceptions.InvalidParamError(`The value of fileInfo.id is empty`);
+            }
+            if (typeof (fileTokenOrInfo.id) !== "string") {
+                throw new exceptions.InvalidParamError(`The type of fileInfo.id should be string, but ${typeof (fileTokenOrInfo)}`);
+            }
+            return await Request.GetInstance().downloadFileByID(fileTokenOrInfo.id, filePath);
+        }
+        else {
+            throw new exceptions.InvalidParamError(`The type of first param should be string or object, but ${typeof (fileTokenOrInfo)}`);
+        }
+    }
+    async upload(data, expire, ...ret) {
+        if (ret.length > 0) {
+            throw new exceptions.InvalidParamError(`params is too many, as ${ret.length + 2}`);
+        }
+        if (!data) {
+            throw new exceptions.InvalidParamError(`params is null`);
+        }
+        // 1. data is filePath, read it from disk, convert it to Steam.
+        if (typeof (data) === 'string') {
+            if (!fs.existsSync(data)) {
+                throw new exceptions.InvalidParamError(`no such file '${data}'`);
+            }
+            data = fs.createReadStream(data);
+        }
+        // 2. data must be Stream at here.
+        return await Request.GetInstance().uploadFile(data, expire);
+    }
+}
+exports._KunlunFile = _KunlunFile;
+/**
+ * OpenSDK 静态资源操作类
+ */
+class _OpenSDKResources {
+    constructor(appCtx) {
+        this.file = new _KunlunOpenSDKFile(appCtx);
+    }
+}
+exports._OpenSDKResources = _OpenSDKResources;
+/**
+ * 静态资源操作类
+ */
+class _Resources {
+    constructor() {
+        this.file = new _KunlunFile();
+    }
+}
+exports._Resources = _Resources;

package/context/resources/impl/resources.ts

@@ -0,0 +1,173 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+import { Stream } from "stream";
+import { _FileInfo, _IKunlunFile, _IOpenSDKFile, UploadAvatarResult, FileUploadResult } from "../IResources";
+import * as Request from "../../../request/interface";
+import { runCtxForOpenSDK } from "../../../application/impl/common";
+import * as common from "@byted-apaas/server-common-node"
+import { AppCtx } from "../../../application/application";
+import { streamToBuffer } from "@jorgeferrero/stream-to-buffer";
+
+const exceptions = common.exceptions;
+
+const fs = require('fs');
+
+export class _KunlunOpenSDKFile implements _IOpenSDKFile {
+    appCtx: AppCtx
+
+    constructor(appCtx: AppCtx) {
+        this.appCtx = appCtx;
+    }
+
+    async Upload(fileName: string, path: string): Promise<FileUploadResult>;
+    async Upload(fileName: string, reader: Stream): Promise<FileUploadResult>;
+    async Upload(fileName: string, buffer: Buffer): Promise<FileUploadResult>;
+    async Upload(fileName: string, source: string | Stream | Buffer): Promise<FileUploadResult> {
+        // 1. check parameters type
+        if (typeof fileName !== 'string') {
+            throw new exceptions.InvalidParamError('upload method parameter fileName must be string. ');
+        }
+        if (typeof source !== 'string' && !(source instanceof Stream) && !(source instanceof Buffer)) {
+            throw new exceptions.InvalidParamError('upload method parameter source must be string or stream or buffer. ');
+        }
+        // 2. divide by source type
+        if (typeof source === 'string') {
+            // upload from path
+            if (!fs.existsSync(source)) {
+                throw new exceptions.InvalidParamError(`no such file '${source}'`)
+            }
+            source = fs.createReadStream(source);
+        }
+        if (source instanceof Stream) {
+            // upload from stream
+            source = await streamToBuffer(source as any);
+        }
+        if (source instanceof Buffer) {
+            return await runCtxForOpenSDK(this.appCtx, async () => {
+                return await Request.GetInstance().openSDKUploadFile(fileName, source as Buffer);
+            });
+        }
+        return null;
+    };
+    async UploadAvatar(fileName: string, path: string): Promise<UploadAvatarResult>;
+    async UploadAvatar(fileName: string, reader: Stream): Promise<UploadAvatarResult>;
+    async UploadAvatar(fileName: string, buffer: Buffer): Promise<UploadAvatarResult>;
+    async UploadAvatar(fileName: string, source: string | Stream | Buffer): Promise<UploadAvatarResult> {
+        // 1. check parameters type
+        if (typeof fileName !== 'string') {
+            throw new exceptions.InvalidParamError('upload method parameter fileName must be string. ');
+        }
+        if (typeof source !== 'string' && !(source instanceof Stream) && !(source instanceof Buffer)) {
+            throw new exceptions.InvalidParamError('upload method parameter source must be string or stream or buffer. ');
+        }
+        // 2. divide by source type
+        if (typeof source === 'string') {
+            // upload from path
+            if (!fs.existsSync(source)) {
+                throw new exceptions.InvalidParamError(`no such file '${source}'`)
+            }
+            source = fs.createReadStream(source);
+        }
+        if (source instanceof Stream) {
+            // upload from stream
+            source = await streamToBuffer(source as any);
+        }
+        if (source instanceof Buffer) {
+            // upload from buffer
+            return await runCtxForOpenSDK(this.appCtx, async () => {
+                return await Request.GetInstance().openSDKUploadAvatar(fileName, source as Buffer);
+            })
+        }
+        return null;
+    };
+    async Download(fileID: string): Promise<Buffer> {
+        // 1. check parameters type
+        if (typeof fileID !== 'string') {
+            throw new exceptions.InvalidParamError('download method parameter fileID must be string. ');
+        }
+        return await runCtxForOpenSDK(this.appCtx, async () => {
+            return await Request.GetInstance().downloadFileByID(fileID) as Buffer;
+        })
+    };
+    async DownloadAvatar(imageID: string): Promise<Buffer> {
+        // 1. check parameters type
+        if (typeof imageID !== 'string') {
+            throw new exceptions.InvalidParamError('download method parameter imageID must be string. ');
+        }
+        return await runCtxForOpenSDK(this.appCtx, async () => {
+            return await Request.GetInstance().openSDKDownloadAvatar(imageID) as Buffer;
+        })
+    };
+}
+
+export class _KunlunFile implements _IKunlunFile {
+    async download(fileToken: string): Promise<Buffer>;
+    async download(fileToken: string, filePath?: string): Promise<void>;
+    async download(fileToken: _FileInfo): Promise<Buffer>;
+    async download(fileInfo: _FileInfo, filePath: string): Promise<void>;
+    async download(fileTokenOrInfo: string | _FileInfo, filePath?: string): Promise<Buffer | void> {
+        if (typeof (fileTokenOrInfo) === "string") {
+            return await Request.GetInstance().downloadFileByToken(fileTokenOrInfo, filePath);
+        } else if (typeof (fileTokenOrInfo) === "object") {
+            if (!fileTokenOrInfo.id) {
+                throw new exceptions.InvalidParamError(`The value of fileInfo.id is empty`);
+            }
+
+            if (typeof (fileTokenOrInfo.id) !== "string") {
+                throw new exceptions.InvalidParamError(`The type of fileInfo.id should be string, but ${typeof (fileTokenOrInfo)}`);
+            }
+            return await Request.GetInstance().downloadFileByID(fileTokenOrInfo.id, filePath);
+        } else {
+            throw new exceptions.InvalidParamError(`The type of first param should be string or object, but ${typeof (fileTokenOrInfo)}`);
+        }
+    }
+
+    async upload(filePath: string): Promise<Request.UploadFileResp>;
+    async upload(stream: Stream): Promise<Request.UploadFileResp>;
+    async upload(filePath: string, expire: number): Promise<Request.UploadFileResp>;
+    async upload(stream: Stream, expire: number): Promise<Request.UploadFileResp>;
+    async upload(data: string | Stream, expire?: number, ...ret: string[]): Promise<Request.UploadFileResp> {
+        if (ret.length > 0) {
+            throw new exceptions.InvalidParamError(`params is too many, as ${ret.length + 2}`)
+        }
+        if (!data) {
+            throw new exceptions.InvalidParamError(`params is null`)
+        }
+
+        // 1. data is filePath, read it from disk, convert it to Steam.
+        if (typeof (data) === 'string') {
+            if (!fs.existsSync(data)) {
+                throw new exceptions.InvalidParamError(`no such file '${data}'`)
+            }
+            data = fs.createReadStream(data);
+        }
+
+        // 2. data must be Stream at here.
+        return await Request.GetInstance().uploadFile(data as Stream, expire);
+    }
+}
+
+/**
+ * OpenSDK 静态资源操作类
+ */
+export class _OpenSDKResources {
+    file: _IOpenSDKFile;
+
+    constructor(appCtx: AppCtx) {
+        this.file = new _KunlunOpenSDKFile(appCtx);
+    }
+}
+
+/**
+ * 静态资源操作类
+ */
+export class _Resources {
+
+    file: _IKunlunFile;
+
+    constructor() {
+        this.file = new _KunlunFile();
+    }
+
+}

package/context/tasks/tasks.d.ts

@@ -0,0 +1,33 @@
+export declare class _Options {
+    /**
+     * 并发数量，默认值为 5，最大可设置值为 10
+     */
+    concurrency?: number;
+    /**
+     * 单个子任务的最大数据量，默认值为 5，最大可设置值为 100
+     */
+    maxSliceNumber?: number;
+    /**
+     * 触发进度回调函数的步长，以百分比为单位，每当发生大于等于步长的进度变化时，便触发进度回调函数。默认为每当有进度变化时，便触发进度回调函数（进度变化精度为 1%）
+     */
+    progressCallbackStep?: number;
+}
+export declare class Tasks<cf> {
+    private f;
+    constructor(_f?: Function);
+    /**
+     * 创建异步任务
+     * @param apiName 函数的 apiName
+     * @param params 参数
+     */
+    createAsyncTask(apiName: cf, params: object): Promise<void>;
+    /**
+     * 创建分布式任务
+     * @param dataset 待处理数据组成的数组
+     * @param handlerFunc 用于处理数据集的全局函数的 API name
+     * @param progressCallbackFunc 任务进度发生变化时回调的全局函数的 API name，可通过传入 "" / null / undefined 跳过此步骤
+     * @param completedCallbackFunc 任务完成时回调的全局函数的 API name，可通过传入 "" / null / undefined 跳过此步骤
+     * @param options 高级配置参数，可选
+     */
+    createDistributedTask(dataset: any[], handlerFunc: cf, progressCallbackFunc: cf | "" | null | undefined, completedCallbackFunc: cf | "" | null | undefined, options?: _Options): Promise<number>;
+}

package/context/tasks/tasks.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tasks = exports._Options = void 0;
+const common = require("@byted-apaas/server-common-node");
+const Request = require("../../request/interface");
+const utils = common.utils;
+const exceptions = common.exceptions;
+class _Options {
+}
+exports._Options = _Options;
+// export async function asyncTaskV1(apiName: string, params: any, oldFuncName: string, isSync: boolean) {
+//     return await invokeFuncSync(apiName, params, oldFuncName, false);
+// }
+class Tasks {
+    constructor(_f) {
+        this.f = _f;
+    }
+    /**
+     * 创建异步任务
+     * @param apiName 函数的 apiName
+     * @param params 参数
+     */
+    async createAsyncTask(apiName, params) {
+        if (apiName && params) {
+            // low_code 1.0
+            if (utils.isOnlineDev()) { // TODO 区分 4.0 vs 5.0
+                // 1.debug模式
+                if (utils.isDebug()) {
+                    return await this.f(apiName).invoke(params);
+                }
+                // 2.运行时
+                let newApiName = utils.handleFuncName(null, apiName);
+                if (!newApiName) {
+                    throw new exceptions.InvalidParamError(`The function (${apiName}) does not exist, please confirm ${apiName} exists and has been deployed.`);
+                }
+                let idOrName = {};
+                if (newApiName === apiName) {
+                    idOrName = {
+                        APIName: newApiName,
+                        isInvokeByAPIName: true,
+                    };
+                }
+                else if (utils.isMicroservice()) {
+                    idOrName = {
+                        APIName: apiName,
+                        isInvokeByAPIName: true,
+                    };
+                }
+                else {
+                    idOrName = {
+                        APIId: newApiName,
+                        isInvokeByAPIName: false,
+                    };
+                }
+                return {
+                    task_id: await Request.GetInstance().createAsyncTaskV1(idOrName, params),
+                };
+            }
+            // low_code 2.0
+            // 如果是本地调试模式，则直接异步执行
+            if (utils.isLocalDebug()) {
+                this.f(apiName).invoke(params);
+                return { task_id: 1234567890123456 };
+            }
+            return {
+                task_id: await Request.GetInstance().createAsyncTaskV2(apiName, params),
+            };
+        }
+        else {
+            throw new exceptions.InvalidParamError(`context.tasks.createAsyncTask params is error`);
+        }
+    }
+    ;
+    /**
+     * 创建分布式任务
+     * @param dataset 待处理数据组成的数组
+     * @param handlerFunc 用于处理数据集的全局函数的 API name
+     * @param progressCallbackFunc 任务进度发生变化时回调的全局函数的 API name，可通过传入 "" / null / undefined 跳过此步骤
+     * @param completedCallbackFunc 任务完成时回调的全局函数的 API name，可通过传入 "" / null / undefined 跳过此步骤
+     * @param options 高级配置参数，可选
+     */
+    async createDistributedTask(dataset, handlerFunc, progressCallbackFunc, completedCallbackFunc, options) {
+        if (utils.isLocalDebug()) {
+            throw new exceptions.InvalidParamError("Local debugging isn't supported for distributed tasks. You can only deploy them to the cloud");
+        }
+        if (utils.getDistributedHandleMask()) {
+            throw new exceptions.InvalidParamError("Does not support creating distributed tasks in handler function and progress callback function");
+        }
+        // dataset
+        if (!(dataset instanceof Array)) {
+            throw new exceptions.InvalidParamError(`parameter dataset is not list`);
+        }
+        // handlerFunc
+        if (!handlerFunc || typeof handlerFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter handlerFunc is not string or handlerFunc is empty`);
+        }
+        // progressCallbackFunc
+        if (progressCallbackFunc === null || progressCallbackFunc === undefined) {
+            progressCallbackFunc = "";
+        }
+        if (typeof progressCallbackFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter progressCallbackFunc is not string`);
+        }
+        // completedCallbackFunc
+        if (completedCallbackFunc === null || completedCallbackFunc === undefined) {
+            completedCallbackFunc = "";
+        }
+        if (typeof completedCallbackFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter completedCallbackFunc is not string`);
+        }
+        // option.concurrency
+        if (options.concurrency === null || options.concurrency === undefined) {
+            options.concurrency = 5;
+        }
+        if ((typeof options.concurrency !== 'number') || options.concurrency <= 0) {
+            throw new exceptions.InvalidParamError(`parameter option.concurrency is not Number or not graterThan 0`);
+        }
+        // option.maxSliceNumber
+        if (options.maxSliceNumber === null || options.maxSliceNumber === undefined) {
+            options.maxSliceNumber = 5;
+        }
+        if ((typeof options.maxSliceNumber !== 'number') || options.maxSliceNumber <= 0) {
+            throw new exceptions.InvalidParamError(`parameter option.maxSliceNumber is not Number or not graterThan 0`);
+        }
+        // option.notifyStep
+        if (options.progressCallbackStep === null || options.progressCallbackStep === undefined) {
+            options.progressCallbackStep = 1;
+        }
+        if ((typeof options.progressCallbackStep !== 'number') || options.progressCallbackStep <= 0 || options.progressCallbackStep > 100) {
+            throw new exceptions.InvalidParamError(`parameter option.progressCallbackStep is not Number or not between 0 and 100`);
+        }
+        if (utils.isOnlineDev()) {
+            return Request.GetFaaSInfraInstance().createDistributeTaskV1([dataset], handlerFunc, progressCallbackFunc, completedCallbackFunc, options);
+        }
+        return Request.GetFaaSInfraInstance().createDistributeTaskV2([dataset], handlerFunc, progressCallbackFunc, completedCallbackFunc, options);
+    }
+    ;
+}
+exports.Tasks = Tasks;

package/context/tasks/tasks.ts

@@ -0,0 +1,159 @@
+import * as common from "@byted-apaas/server-common-node"
+import * as Request from "../../request/interface"
+
+const utils = common.utils
+const exceptions = common.exceptions
+
+export class _Options {
+    /**
+     * 并发数量，默认值为 5，最大可设置值为 10
+     */
+    concurrency?: number;
+    /**
+     * 单个子任务的最大数据量，默认值为 5，最大可设置值为 100
+     */
+    maxSliceNumber?: number;
+    /**
+     * 触发进度回调函数的步长，以百分比为单位，每当发生大于等于步长的进度变化时，便触发进度回调函数。默认为每当有进度变化时，便触发进度回调函数（进度变化精度为 1%）
+     */
+    progressCallbackStep?: number;
+}
+
+// export async function asyncTaskV1(apiName: string, params: any, oldFuncName: string, isSync: boolean) {
+//     return await invokeFuncSync(apiName, params, oldFuncName, false);
+// }
+
+export class Tasks<cf> {
+    private f: Function
+
+    constructor(_f?: Function) {
+        this.f = _f
+    }
+
+    /**
+     * 创建异步任务
+     * @param apiName 函数的 apiName
+     * @param params 参数
+     */
+    public async createAsyncTask(apiName: cf, params: object): Promise<void> {
+        if (apiName && params) {
+            // low_code 1.0
+            if (utils.isOnlineDev()) {// TODO 区分 4.0 vs 5.0
+                // 1.debug模式
+                if (utils.isDebug()) {
+                    return await this.f(apiName).invoke(params);
+                }
+                // 2.运行时
+                let newApiName = utils.handleFuncName(null, apiName as any);
+                if (!newApiName) {
+                    throw new exceptions.InvalidParamError(`The function (${apiName}) does not exist, please confirm ${apiName} exists and has been deployed.`);
+                }
+                let idOrName: any = {};
+                if (newApiName === apiName) {
+                    idOrName = {
+                        APIName: newApiName,
+                        isInvokeByAPIName: true,
+                    }
+                } else if (utils.isMicroservice()) {
+                    idOrName = {
+                        APIName: apiName,
+                        isInvokeByAPIName: true,
+                    }
+                } else {
+                    idOrName = {
+                        APIId: newApiName,
+                        isInvokeByAPIName: false,
+                    }
+                }
+                return {
+                    task_id: await Request.GetInstance().createAsyncTaskV1(idOrName, params),
+                } as any
+            }
+
+
+            // low_code 2.0
+            // 如果是本地调试模式，则直接异步执行
+            if (utils.isLocalDebug()) {
+                this.f(apiName).invoke(params);
+                return {task_id: 1234567890123456} as any;
+            }
+
+            return {
+                task_id: await Request.GetInstance().createAsyncTaskV2(apiName as string, params),
+            } as any
+        } else {
+            throw new exceptions.InvalidParamError(`context.tasks.createAsyncTask params is error`);
+        }
+    };
+
+    /**
+     * 创建分布式任务
+     * @param dataset 待处理数据组成的数组
+     * @param handlerFunc 用于处理数据集的全局函数的 API name
+     * @param progressCallbackFunc 任务进度发生变化时回调的全局函数的 API name，可通过传入 "" / null / undefined 跳过此步骤
+     * @param completedCallbackFunc 任务完成时回调的全局函数的 API name，可通过传入 "" / null / undefined 跳过此步骤
+     * @param options 高级配置参数，可选
+     */
+    public async createDistributedTask(dataset: any[], handlerFunc: cf, progressCallbackFunc: cf | "" | null | undefined, completedCallbackFunc: cf | "" | null | undefined, options?: _Options): Promise<number> {
+        if (utils.isLocalDebug()) {
+            throw new exceptions.InvalidParamError("Local debugging isn't supported for distributed tasks. You can only deploy them to the cloud");
+        }
+
+        if (utils.getDistributedHandleMask()) {
+            throw new exceptions.InvalidParamError("Does not support creating distributed tasks in handler function and progress callback function");
+        }
+
+        // dataset
+        if (!(dataset instanceof Array)) {
+            throw new exceptions.InvalidParamError(`parameter dataset is not list`);
+        }
+
+        // handlerFunc
+        if (!handlerFunc || typeof handlerFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter handlerFunc is not string or handlerFunc is empty`);
+        }
+
+        // progressCallbackFunc
+        if (progressCallbackFunc === null || progressCallbackFunc === undefined) {
+            progressCallbackFunc = "";
+        }
+        if (typeof progressCallbackFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter progressCallbackFunc is not string`);
+        }
+
+        // completedCallbackFunc
+        if (completedCallbackFunc === null || completedCallbackFunc === undefined) {
+            completedCallbackFunc = "";
+        }
+        if (typeof completedCallbackFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter completedCallbackFunc is not string`);
+        }
+
+        // option.concurrency
+        if (options.concurrency === null || options.concurrency === undefined) {
+            options.concurrency = 5;
+        }
+        if ((typeof options.concurrency !== 'number') || options.concurrency <= 0) {
+            throw new exceptions.InvalidParamError(`parameter option.concurrency is not Number or not graterThan 0`);
+        }
+        // option.maxSliceNumber
+        if (options.maxSliceNumber === null || options.maxSliceNumber === undefined) {
+            options.maxSliceNumber = 5;
+        }
+        if ((typeof options.maxSliceNumber !== 'number') || options.maxSliceNumber <= 0) {
+            throw new exceptions.InvalidParamError(`parameter option.maxSliceNumber is not Number or not graterThan 0`);
+        }
+        // option.notifyStep
+        if (options.progressCallbackStep === null || options.progressCallbackStep === undefined) {
+            options.progressCallbackStep = 1;
+        }
+        if ((typeof options.progressCallbackStep !== 'number') || options.progressCallbackStep <= 0 || options.progressCallbackStep > 100) {
+            throw new exceptions.InvalidParamError(`parameter option.progressCallbackStep is not Number or not between 0 and 100`);
+        }
+
+        if (utils.isOnlineDev()) {
+            return Request.GetFaaSInfraInstance().createDistributeTaskV1([dataset], handlerFunc, progressCallbackFunc, completedCallbackFunc, options);
+        }
+        return Request.GetFaaSInfraInstance().createDistributeTaskV2([dataset], handlerFunc, progressCallbackFunc, completedCallbackFunc, options);
+    };
+}

package/data/index.d.ts

@@ -0,0 +1,27 @@
+export interface workflowVariables {
+}
+export declare type globalFuncNames = "a" | "b";
+export interface globalVariablesMap {
+    a: string;
+    b: string;
+}
+export declare type globalVariables = keyof globalVariablesMap;
+export interface metadataMap {
+    /**
+     * @description 用户
+     */
+    _user: User;
+    _department: Department;
+}
+export declare type currentObjApiName = "_user";
+interface User {
+    _name: string;
+    _id: number;
+    _department: Department;
+}
+interface Department {
+    _id: number;
+    _name: string;
+    _superior: Department;
+}
+export {};