@or-sdk/flows 0.26.1 → 0.27.0-beta.427.0

package/dist/cjs/Flows.js

@@ -1,4 +1,19 @@
 "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++) {
@@ -46,234 +61,422 @@ 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 __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));
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flows = void 0;
 var base_1 = require("@or-sdk/base");
-var data_hub_1 = require("@or-sdk/data-hub");
-var deployer_1 = require("@or-sdk/deployer");
+var lodash_1 = __importDefault(require("lodash"));
+var uuid_1 = require("uuid");
 var constants_1 = require("./constants");
-var tags_1 = require("@or-sdk/tags");
 var utils_1 = require("./utils");
-var Flows = (function () {
+var Flows = (function (_super) {
+    __extends(Flows, _super);
     function Flows(params) {
-        var discoveryUrl = params.discoveryUrl, token = params.token, accountId = params.accountId, dataHubUrl = params.dataHubUrl, deployerUrl = params.deployerUrl;
-        this.dataHub = new data_hub_1.DataHub({
+        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, {
             token: token,
             discoveryUrl: discoveryUrl,
+            serviceKey: constants_1.SERVICE_KEY,
             accountId: accountId,
-            dataHubUrl: dataHubUrl,
+            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];
+            });
         });
-        this.deployer = new deployer_1.Deployer({
-            token: token,
-            discoveryUrl: discoveryUrl,
-            accountId: accountId,
-            deployerUrl: deployerUrl,
+    };
+    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',
+                    })];
+            });
         });
-        this.tags = new tags_1.Tags({
-            token: token,
-            discoveryUrl: discoveryUrl,
-            accountId: accountId,
-            dataHubUrl: dataHubUrl,
+    };
+    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.init = function () {
+    };
+    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),
+                    })];
+            });
+        });
+    };
+    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',
+                    })];
+            });
+        });
+    };
+    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 },
+                    })];
+            });
+        });
+    };
+    Flows.prototype.getVersion = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4, Promise.all([
-                            this.dataHub.init(),
-                            this.deployer.init(),
-                            this.tags.init(),
-                        ])];
+                    case 0: return [4, this.listVersions(params)];
                     case 1:
-                        _a.sent();
-                        return [2];
+                        data = _a.sent();
+                        return [2, data[0]];
                 }
             });
         });
     };
-    Flows.prototype.listFlows = function (botId, params) {
+    Flows.prototype.listFlowVersionsByBotId = function (params) {
         return __awaiter(this, void 0, void 0, function () {
-            var requestParams, route, result, flowList, query, projection;
             return __generator(this, function (_a) {
-                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)];
-                }
+                return [2, this.listVersions(params)];
             });
         });
     };
-    Flows.prototype.getFlow = function (id) {
+    Flows.prototype.loadLogs = function (params) {
         return __awaiter(this, void 0, void 0, function () {
-            var route, params;
+            var flowId, next, startTime, endTime, limit, filter, relativeTime, queryParams;
             return __generator(this, function (_a) {
-                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()];
+                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;
+                }
+                return [2, this.callApiV2({
+                        url: this.deployerUrl,
+                        route: "/flows/".concat(flowId, "/logs"),
+                        params: queryParams,
+                    })];
             });
         });
     };
-    Flows.prototype.saveFlow = function (source) {
+    Flows.prototype.saveFlow = function (flow, _a) {
+        var _b = _a === void 0 ? {} : _a, previousVersion = _b.previousVersion;
         return __awaiter(this, void 0, void 0, function () {
-            var route, data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var _c, id, version;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        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,
+                        flow.id = flow.id || 'new';
+                        return [4, this.callApiV2({
+                                route: "/flows/".concat(flow.id),
+                                data: {
+                                    flow: flow,
+                                    previousVersion: previousVersion,
+                                },
+                                method: 'post',
                             })];
-                    case 1: return [2, _a.sent()];
+                    case 1:
+                        _c = _d.sent(), id = _c.id, version = _c.version;
+                        return [2, __assign(__assign({}, flow), { id: id, version: version })];
                 }
             });
         });
     };
-    Flows.prototype.deleteFlow = function (source, flowAlias) {
-        if (flowAlias === void 0) { flowAlias = 'dev'; }
+    Flows.prototype.getFlowsByBotId = function (botId, projection) {
+        return this.getFlows({
+            query: { botId: botId },
+            projection: projection,
+        });
+    };
+    Flows.prototype.getRemoteDataOutsByBotId = function (id) {
         return __awaiter(this, void 0, void 0, function () {
-            var variables, operationName, data, result;
+            var flows, dataOuts;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    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,
+                    case 0: return [4, this.getFlows({
+                            query: {
+                                botId: id,
+                                isDeleted: false,
                             },
-                        };
-                        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,
-                            })];
+                            projection: ['id', 'data.label'],
+                        })];
                     case 1:
-                        result = _a.sent();
-                        return [2, this.dataHub.subscribe(result.data[operationName].requestId)];
+                        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; }),
+                                    },
+                                },
+                            })];
+                    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;
+                            }, {})];
                 }
             });
         });
     };
-    Flows.prototype.activateFlow = function (source, interactiveDebug) {
-        if (interactiveDebug === void 0) { interactiveDebug = false; }
+    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) {
         return __awaiter(this, void 0, void 0, function () {
+            var flow, template;
             return __generator(this, function (_a) {
-                return [2, this.deployer.activateFlow(source, interactiveDebug)];
+                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)];
             });
         });
     };
-    Flows.prototype.deactivateFlow = function (source, flowAlias, deleteLambda) {
-        if (deleteLambda === void 0) { deleteLambda = false; }
+    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.deployer.deactivateFlow(source, flowAlias, deleteLambda)];
+                return [2, this.getFlows(__assign(__assign({}, params), { query: { botId: botId } }))];
             });
         });
     };
-    Flows.prototype.addTags = function (source, tagNames) {
+    Flows.prototype.getFlow = function (id) {
         return __awaiter(this, void 0, void 0, function () {
-            var tags, tagIds, newIds;
+            return __generator(this, function (_a) {
+                return [2, this.getFlowById(id)];
+            });
+        });
+    };
+    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) {
+        return __awaiter(this, void 0, void 0, function () {
+            var counter, result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4, this.tags.getMultipleTagsByName(tagNames, true)];
+                    case 0:
+                        counter = 0;
+                        _a.label = 1;
                     case 1:
-                        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.');
+                        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);
                         }
-                        return [2, this.saveFlow(__assign(__assign({}, source), { tags: (0, tags_1.addTagsIds)(source.tags, newIds) }))];
+                        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)];
                 }
             });
         });
     };
-    Flows.prototype.removeTags = function (source, tagNames) {
+    Flows.prototype.deactivateFlow = function (flow, flowAlias, deleteLambda) {
+        if (deleteLambda === void 0) { deleteLambda = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var tags, tagIds, existingIds;
+            var requestId;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4, this.tags.getMultipleTagsByName(tagNames)];
+                    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 1:
-                        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) }))];
+                        requestId = (_a.sent()).requestId;
+                        return [2, this._pollResult(flow.id, requestId)];
                 }
             });
         });
@@ -286,6 +489,6 @@ var Flows = (function () {
         return (0, utils_1.deleteUnusedStepTemplates)(source, stepTemplates);
     };
     return Flows;
-}());
+}(base_1.Base));
 exports.Flows = Flows;
 //# sourceMappingURL=Flows.js.map