@or-sdk/flows 0.27.0-beta.427.0 → 0.27.1-beta.531.0

package/dist/cjs/Flows.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -61,422 +46,234 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flows = void 0;
 var base_1 = require("@or-sdk/base");
-var lodash_1 = __importDefault(require("lodash"));
-var uuid_1 = require("uuid");
+var data_hub_1 = require("@or-sdk/data-hub");
+var deployer_1 = require("@or-sdk/deployer");
 var constants_1 = require("./constants");
+var tags_1 = require("@or-sdk/tags");
 var utils_1 = require("./utils");
-var Flows = (function (_super) {
-    __extends(Flows, _super);
+var Flows = (function () {
     function Flows(params) {
-        var _this = this;
-        var discoveryUrl = params.discoveryUrl, token = params.token, accountId = params.accountId, dataHub2Url = params.dataHub2Url, deployerUrl = params.deployerUrl, sdkApiUrl = params.sdkApiUrl;
-        _this = _super.call(this, {
+        var discoveryUrl = params.discoveryUrl, token = params.token, accountId = params.accountId, dataHubUrl = params.dataHubUrl, deployerUrl = params.deployerUrl;
+        this.dataHub = new data_hub_1.DataHub({
             token: token,
             discoveryUrl: discoveryUrl,
-            serviceKey: constants_1.SERVICE_KEY,
             accountId: accountId,
-            serviceUrl: dataHub2Url,
-        }) || this;
-        _this.deployerUrl = deployerUrl;
-        _this.sdkApiUrl = sdkApiUrl;
-        return _this;
-    }
-    Flows.prototype.init = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2];
-            });
-        });
-    };
-    Flows.prototype.deleteFlow = function (flow, flowAlias, temporarily) {
-        if (flowAlias === void 0) { flowAlias = 'dev'; }
-        if (temporarily === void 0) { temporarily = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2, this.callApiV2({
-                        route: "/flows/".concat(flow.id),
-                        data: {
-                            flowAlias: flowAlias,
-                            temporarily: temporarily,
-                        },
-                        method: 'delete',
-                    })];
-            });
-        });
-    };
-    Flows.prototype.recoverFlow = function (flow) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2, this.callApiV2({
-                        route: "/flows/".concat(flow.id),
-                        method: 'patch',
-                    })];
-            });
-        });
-    };
-    Flows.prototype.getFlowById = function (id, projection, sandbox) {
-        if (sandbox === void 0) { sandbox = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2, this.callApiV2({
-                        route: "/flows/".concat(id),
-                        params: {
-                            projection: projection,
-                            sandbox: sandbox,
-                        },
-                    })];
-            });
-        });
-    };
-    Flows.prototype.getFlows = function (_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.query, query = _c === void 0 ? {} : _c, projection = _b.projection, _d = _b.includeDeleted, includeDeleted = _d === void 0 ? false : _d, _e = _b.includeExisting, includeExisting = _e === void 0 ? true : _e, _f = _b.sandbox, sandbox = _f === void 0 ? false : _f, limit = _b.limit, offset = _b.offset;
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_g) {
-                if (typeof query.id === 'string')
-                    query.id = query.id.split('.');
-                if (includeDeleted && !includeExisting)
-                    query.isDeleted = true;
-                if (!includeDeleted && includeExisting)
-                    query.isDeleted = false;
-                return [2, this.callApiV2({
-                        route: '/flows',
-                        params: {
-                            projection: projection,
-                            query: query,
-                            sandbox: sandbox,
-                            limit: limit,
-                            offset: offset,
-                        },
-                    })];
-            });
-        });
-    };
-    Flows.prototype.getFlowEvents = function (_a) {
-        var flowId = _a.flowId, _b = _a.alias, alias = _b === void 0 ? 'prod' : _b;
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                return [2, this.callApiV2({
-                        url: this.sdkApiUrl,
-                        route: "".concat(this.sdkApiUrl, "/event-manager/get-flow-events/").concat(flowId, "/").concat(alias),
-                    })];
-            });
+            dataHubUrl: dataHubUrl,
         });
-    };
-    Flows.prototype.getTriggerFlows = function (triggers) {
-        if (triggers === void 0) { triggers = []; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2, this.callApiV2({
-                        url: this.sdkApiUrl,
-                        route: "".concat(this.sdkApiUrl, "event-manager/get-trigger-flows"),
-                        data: { triggers: triggers },
-                        method: 'post',
-                    })];
-            });
+        this.deployer = new deployer_1.Deployer({
+            token: token,
+            discoveryUrl: discoveryUrl,
+            accountId: accountId,
+            deployerUrl: deployerUrl,
         });
-    };
-    Flows.prototype.listVersions = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2, this.callApiV2({
-                        route: '/flows/versions',
-                        params: { query: query },
-                    })];
-            });
+        this.tags = new tags_1.Tags({
+            token: token,
+            discoveryUrl: discoveryUrl,
+            accountId: accountId,
+            dataHubUrl: dataHubUrl,
         });
-    };
-    Flows.prototype.getVersion = function (params) {
+    }
+    Flows.prototype.init = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var data;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4, this.listVersions(params)];
+                    case 0: return [4, Promise.all([
+                            this.dataHub.init(),
+                            this.deployer.init(),
+                            this.tags.init(),
+                        ])];
                     case 1:
-                        data = _a.sent();
-                        return [2, data[0]];
+                        _a.sent();
+                        return [2];
                 }
             });
         });
     };
-    Flows.prototype.listFlowVersionsByBotId = function (params) {
+    Flows.prototype.listFlows = function (botId, params) {
         return __awaiter(this, void 0, void 0, function () {
+            var requestParams, route, result, flowList, query, projection;
             return __generator(this, function (_a) {
-                return [2, this.listVersions(params)];
+                switch (_a.label) {
+                    case 0:
+                        requestParams = __assign({ includeDeleted: false, includeExisting: true, projection: [
+                                'id',
+                                'version',
+                                'botId',
+                                'data.label',
+                                'data.color',
+                                'data.description',
+                                'data.isHidden',
+                                'tags',
+                                'dateModified',
+                            ] }, params);
+                        route = "/v2/".concat(this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current', "/flows");
+                        flowList = [];
+                        query = { botId: botId ? botId : undefined };
+                        projection = JSON.stringify(requestParams.projection);
+                        _a.label = 1;
+                    case 1: return [4, this.dataHub.makeRequest({
+                            method: 'GET',
+                            route: route,
+                            params: {
+                                includeDeleted: requestParams.includeDeleted,
+                                includeExisting: requestParams.includeExisting,
+                                projection: projection,
+                                query: JSON.stringify(query),
+                            },
+                        })];
+                    case 2:
+                        result = _a.sent();
+                        flowList = __spreadArray(__spreadArray([], flowList, true), result.items, true);
+                        query.last = result.last;
+                        _a.label = 3;
+                    case 3:
+                        if (result.last) return [3, 1];
+                        _a.label = 4;
+                    case 4: return [2, (0, base_1.makeList)(flowList)];
+                }
             });
         });
     };
-    Flows.prototype.loadLogs = function (params) {
+    Flows.prototype.getFlow = function (id) {
         return __awaiter(this, void 0, void 0, function () {
-            var flowId, next, startTime, endTime, limit, filter, relativeTime, queryParams;
+            var route, params;
             return __generator(this, function (_a) {
-                flowId = params.flowId, next = params.next, startTime = params.startTime, endTime = params.endTime, limit = params.limit, filter = params.filter, relativeTime = params.relativeTime;
-                queryParams = { skipOriginal: true };
-                if (next) {
-                    queryParams.next = next;
-                }
-                if (startTime) {
-                    queryParams.start = startTime;
-                }
-                if (endTime) {
-                    queryParams.end = endTime;
-                }
-                if (limit) {
-                    queryParams.limit = limit;
-                }
-                if (filter) {
-                    queryParams.filter = filter;
-                }
-                if (relativeTime) {
-                    queryParams.relativeTime = relativeTime;
+                switch (_a.label) {
+                    case 0:
+                        route = "/v2/".concat(this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current', "/flow/").concat(id);
+                        params = {
+                            includeDeleted: false,
+                            includeExisting: true,
+                            sandbox: false,
+                        };
+                        return [4, this.dataHub.makeRequest({
+                                method: 'GET',
+                                route: route,
+                                params: params,
+                            })];
+                    case 1: return [2, _a.sent()];
                 }
-                return [2, this.callApiV2({
-                        url: this.deployerUrl,
-                        route: "/flows/".concat(flowId, "/logs"),
-                        params: queryParams,
-                    })];
             });
         });
     };
-    Flows.prototype.saveFlow = function (flow, _a) {
-        var _b = _a === void 0 ? {} : _a, previousVersion = _b.previousVersion;
+    Flows.prototype.saveFlow = function (source) {
         return __awaiter(this, void 0, void 0, function () {
-            var _c, id, version;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var route, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        flow.id = flow.id || 'new';
-                        return [4, this.callApiV2({
-                                route: "/flows/".concat(flow.id),
-                                data: {
-                                    flow: flow,
-                                    previousVersion: previousVersion,
-                                },
-                                method: 'post',
+                        route = "/v2/".concat(this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current', "/flow/").concat(source.id ? source.id : 'new');
+                        data = {
+                            flow: source,
+                            previousVersion: source.id ? source.version : undefined,
+                        };
+                        return [4, this.dataHub.makeRequest({
+                                method: 'POST',
+                                route: route,
+                                data: data,
                             })];
-                    case 1:
-                        _c = _d.sent(), id = _c.id, version = _c.version;
-                        return [2, __assign(__assign({}, flow), { id: id, version: version })];
+                    case 1: return [2, _a.sent()];
                 }
             });
         });
     };
-    Flows.prototype.getFlowsByBotId = function (botId, projection) {
-        return this.getFlows({
-            query: { botId: botId },
-            projection: projection,
-        });
-    };
-    Flows.prototype.getRemoteDataOutsByBotId = function (id) {
+    Flows.prototype.deleteFlow = function (source, flowAlias) {
+        if (flowAlias === void 0) { flowAlias = 'dev'; }
         return __awaiter(this, void 0, void 0, function () {
-            var flows, dataOuts;
+            var variables, operationName, data, result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4, this.getFlows({
-                            query: {
-                                botId: id,
-                                isDeleted: false,
+                    case 0:
+                        if (this.dataHub.isCrossAccount) {
+                            throw Error('Cross-account deleting is not implemented.');
+                        }
+                        variables = {
+                            entity: constants_1.ENTITY_NAME,
+                            data: {
+                                id: source.id,
+                                flowAlias: flowAlias,
+                                subscribe: true,
+                                role: source.data.deploy.role,
                             },
-                            projection: ['id', 'data.label'],
-                        })];
-                    case 1:
-                        flows = _a.sent();
-                        return [4, this.callApiV2({
-                                route: 'flows/data-outs',
-                                params: {
-                                    query: {
-                                        type: {
-                                            not: 'session',
-                                            ne: null,
-                                        },
-                                        name: { ne: null },
-                                        botId: id,
-                                        flowId: flows.map(function (flow) { return flow.id; }),
-                                    },
-                                },
+                        };
+                        operationName = this.dataHub.getOperationName(data_hub_1.OperationNames.DELETE_TEMPORARILY);
+                        data = {
+                            operationName: operationName,
+                            query: constants_1.QUERY_DELETE,
+                            variables: variables,
+                        };
+                        return [4, this.dataHub.makeRequest({
+                                method: 'POST',
+                                route: '/graphql',
+                                data: data,
                             })];
-                    case 2:
-                        dataOuts = _a.sent();
-                        return [2, lodash_1.default.reduce(flows, function (acc, flow) {
-                                var flowLabel = lodash_1.default.get(flow, 'data.label', 'No name flow');
-                                acc[flow.id] = lodash_1.default.map(dataOuts, function (dataOut) { return (__assign(__assign({}, dataOut), { flowLabel: flowLabel })); });
-                                return acc;
-                            }, {})];
+                    case 1:
+                        result = _a.sent();
+                        return [2, this.dataHub.subscribe(result.data[operationName].requestId)];
                 }
             });
         });
     };
-    Flows.getEmptyStep = function (stepId) {
-        return {
-            id: stepId || (0, uuid_1.v4)(),
-            icon: 'add',
-            iconType: 'default',
-            iconUrl: '',
-            shape: 'empty',
-            type: 'empty',
-            pinLabel: true,
-            stepInputData: {},
-        };
-    };
-    Flows.getEmptyFlow = function (botId) {
-        var defaultLambdaMemorySize = 1024;
-        var defaultLambdaTimeout = 30;
-        return {
-            botId: botId,
-            data: {
-                label: '',
-                description: '',
-                deploy: {
-                    memory: defaultLambdaMemorySize,
-                    timeout: defaultLambdaTimeout,
-                    role: 'USER',
-                },
-                meta: {},
-                color: null,
-                categories: null,
-                annotations: null,
-                stepTemplates: [],
-                trees: {
-                    main: {
-                        position: {
-                            x: 0,
-                            y: 0,
-                        },
-                        steps: [this.getEmptyStep()],
-                    },
-                },
-            },
-        };
-    };
-    Flows.getNewFlow = function (botId, flowTemplate) {
+    Flows.prototype.activateFlow = function (source, interactiveDebug) {
+        if (interactiveDebug === void 0) { interactiveDebug = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var flow, template;
             return __generator(this, function (_a) {
-                flow = this.getEmptyFlow(botId);
-                template = lodash_1.default.omit(flowTemplate, ['id', 'botId', 'dateCreated', 'dateModified', 'version']);
-                flow.data.steps = lodash_1.default.get(template, 'data.steps.length') > 0 ? [] : flow.data.steps;
-                return [2, lodash_1.default.merge(flow, template)];
+                return [2, this.deployer.activateFlow(source, interactiveDebug)];
             });
         });
     };
-    Flows.prototype.listFlows = function (botId, params) {
-        if (params === void 0) { params = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2, this.getFlows(__assign(__assign({}, params), { query: { botId: botId } }))];
-            });
-        });
-    };
-    Flows.prototype.getFlow = function (id) {
+    Flows.prototype.deactivateFlow = function (source, flowAlias, deleteLambda) {
+        if (deleteLambda === void 0) { deleteLambda = false; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2, this.getFlowById(id)];
+                return [2, this.deployer.deactivateFlow(source, flowAlias, deleteLambda)];
             });
         });
     };
-    Object.defineProperty(Flows.prototype, "deployUrl", {
-        get: function () {
-            return this.targetAccountId ? "".concat(this.deployerUrl, "/accounts/").concat(this.targetAccountId, "/flows/deploy") : "".concat(this.deployerUrl, "/flows/deploy");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Flows.prototype, "checkUrl", {
-        get: function () {
-            return this.targetAccountId ? "".concat(this.deployerUrl, "/accounts/").concat(this.targetAccountId, "/flows/check") : "".concat(this.deployerUrl, "/flows/check");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Flows.prototype._pollResult = function (flowId, requestId, headers, progresCallback) {
+    Flows.prototype.addTags = function (source, tagNames) {
         return __awaiter(this, void 0, void 0, function () {
-            var counter, result;
+            var tags, tagIds, newIds;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        counter = 0;
-                        _a.label = 1;
+                    case 0: return [4, this.tags.getMultipleTagsByName(tagNames, true)];
                     case 1:
-                        counter++;
-                        return [4, new Promise(function (r) { return setTimeout(r, 1000); })];
-                    case 2:
-                        _a.sent();
-                        return [4, this.callApiV2({
-                                url: "".concat(this.checkUrl),
-                                route: "/".concat(flowId, "/").concat(requestId),
-                            })];
-                    case 3:
-                        result = _a.sent();
-                        if (lodash_1.default.isFunction(progresCallback)) {
-                            progresCallback(result);
+                        tags = _a.sent();
+                        tagIds = tags.map(function (tag) { return tag.id; });
+                        newIds = (0, tags_1.filterTagIds)(source.tags, tagIds).newIds;
+                        if (!newIds.length) {
+                            throw Error('No tags to add.');
                         }
-                        if (result.status !== 'pending') {
-                            if (result.errorData) {
-                                throw result;
-                            }
-                            return [2, result];
-                        }
-                        _a.label = 4;
-                    case 4:
-                        if (counter < 100) return [3, 1];
-                        _a.label = 5;
-                    case 5: throw new Error('Activation duration is too long');
-                }
-            });
-        });
-    };
-    Flows.prototype.activateFlow = function (flow, progresCallback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var flowAlias, requestId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        flowAlias = "v-".concat(Date.now());
-                        return [4, this.callApiV2({
-                                url: this.deployUrl,
-                                route: '',
-                                method: 'post',
-                                data: {
-                                    flowId: flow.id,
-                                    flowAlias: flowAlias,
-                                    interactiveDebug: flow.interactiveDebug,
-                                    role: lodash_1.default.get(flow, 'data.deploy.role'),
-                                },
-                            })];
-                    case 1:
-                        requestId = (_a.sent()).requestId;
-                        return [2, this._pollResult(flow.id, requestId, null, progresCallback)];
+                        return [2, this.saveFlow(__assign(__assign({}, source), { tags: (0, tags_1.addTagsIds)(source.tags, newIds) }))];
                 }
             });
         });
     };
-    Flows.prototype.deactivateFlow = function (flow, flowAlias, deleteLambda) {
-        if (deleteLambda === void 0) { deleteLambda = false; }
+    Flows.prototype.removeTags = function (source, tagNames) {
         return __awaiter(this, void 0, void 0, function () {
-            var requestId;
+            var tags, tagIds, existingIds;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4, this.callApiV2({
-                            url: this.deployUrl,
-                            route: '',
-                            method: 'delete',
-                            data: {
-                                flow: {
-                                    id: flow.id,
-                                },
-                                flowAlias: flowAlias,
-                                role: lodash_1.default.get(flow, 'data.deploy.role'),
-                                deleteLambda: deleteLambda,
-                            },
-                        })];
+                    case 0: return [4, this.tags.getMultipleTagsByName(tagNames)];
                     case 1:
-                        requestId = (_a.sent()).requestId;
-                        return [2, this._pollResult(flow.id, requestId)];
+                        tags = _a.sent();
+                        tagIds = tags.map(function (tag) { return tag.id; });
+                        existingIds = (0, tags_1.filterTagIds)(source.tags, tagIds).existingIds;
+                        if (!existingIds.length) {
+                            throw Error('No tags to remove.');
+                        }
+                        return [2, this.saveFlow(__assign(__assign({}, source), { tags: (0, tags_1.removeTagIds)(source.tags, existingIds) }))];
                 }
             });
         });
@@ -489,6 +286,6 @@ var Flows = (function (_super) {
         return (0, utils_1.deleteUnusedStepTemplates)(source, stepTemplates);
     };
     return Flows;
-}(base_1.Base));
+}());
 exports.Flows = Flows;
 //# sourceMappingURL=Flows.js.map