@prisme.ai/sdk 0.0.2

package/dist/sdk/lib/api.js

@@ -0,0 +1,553 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.js');
+var QueryString = require('qs');
+var fetcher = require('./fetcher.js');
+var events = require('./events.js');
+var utils = require('./utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var QueryString__default = /*#__PURE__*/_interopDefaultLegacy(QueryString);
+
+var Api = /** @class */ (function (_super) {
+    _tslib.__extends(Api, _super);
+    function Api() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Api.prototype.me = function () {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get('/me')];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.signin = function (email, password) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post('/login', {
+                            email: email,
+                            password: password,
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.signup = function (email, password, firstName, lastName) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post('/signup', {
+                            email: email,
+                            password: password,
+                            firstName: firstName,
+                            lastName: lastName,
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.signout = function () {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post('/logout')];
+                    case 1:
+                        _a.sent();
+                        this.token = null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Workspaces
+    Api.prototype.getWorkspaces = function () {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get('/workspaces?limit=300')];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.getWorkspace = function (id) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get("/workspaces/".concat(id))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.createWorkspace = function (name) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post('/workspaces', { name: name })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.updateWorkspace = function (workspace) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return _tslib.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = this.patch;
+                        _b = ["/workspaces/".concat(workspace.id)];
+                        return [4 /*yield*/, this.replaceAllImagesData(workspace, workspace.id)];
+                    case 1: return [4 /*yield*/, _a.apply(this, _b.concat([_c.sent()]))];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.deleteWorkspace = function (workspaceId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.delete("/workspaces/".concat(workspaceId))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // Automations
+    Api.prototype.createAutomation = function (workspace, automation) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post("/workspaces/".concat(workspace.id, "/automations"), _tslib.__assign({}, automation))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.updateAutomation = function (workspace, slug, automation) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return _tslib.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = this.patch;
+                        _b = ["/workspaces/".concat(workspace.id, "/automations/").concat(slug)];
+                        return [4 /*yield*/, this.replaceAllImagesData(automation, workspace.id)];
+                    case 1: return [4 /*yield*/, _a.apply(this, _b.concat([_c.sent()]))];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.deleteAutomation = function (workspace, slug) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.delete("/workspaces/".concat(workspace.id, "/automations/").concat(slug))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // Pages
+    Api.prototype.getPages = function (workspaceId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var pages;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.get("/workspaces/".concat(workspaceId, "/pages"))];
+                    case 1:
+                        pages = _a.sent();
+                        return [2 /*return*/, pages.map(function (_a) {
+                                _a.createdAt; _a.createdBy; _a.updatedAt; _a.updatedBy; var page = _tslib.__rest(_a, ["createdAt", "createdBy", "updatedAt", "updatedBy"]);
+                                return page;
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, []];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Api.prototype.getPage = function (workspaceId, pageId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get("/workspaces/".concat(workspaceId, "/pages/").concat(pageId))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.getPageBySlug = function (pageSlug) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get("/pages/".concat(pageSlug))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.createPage = function (workspaceId, page) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _a, newPage;
+            return _tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.post("/workspaces/".concat(workspaceId, "/pages"), page)];
+                    case 1:
+                        _a = _b.sent(), newPage = _tslib.__rest(_a, ["createdAt", "createdBy", "updatedAt", "updatedBy"]);
+                        return [2 /*return*/, newPage];
+                }
+            });
+        });
+    };
+    // Replace images as dataurl to uploaded url in any type of data
+    Api.prototype.updatePage = function (workspaceId, page) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _a, updatedPage, _b, _c;
+            return _tslib.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = this.patch;
+                        _c = ["/workspaces/".concat(workspaceId, "/pages/").concat(page.id)];
+                        return [4 /*yield*/, this.replaceAllImagesData(page, workspaceId)];
+                    case 1: return [4 /*yield*/, _b.apply(this, _c.concat([_d.sent()]))];
+                    case 2:
+                        _a = _d.sent(), updatedPage = _tslib.__rest(_a, ["createdAt", "createdBy", "updatedAt", "updatedBy"]);
+                        return [2 /*return*/, updatedPage];
+                }
+            });
+        });
+    };
+    Api.prototype.deletePage = function (workspaceId, pageId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.delete("/workspaces/".concat(workspaceId, "/pages/").concat(pageId))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // Events
+    Api.prototype.streamEvents = function (workspaceId) {
+        var events$1 = new events.Events(workspaceId, this.token || '', this.host);
+        return new Promise(function (resolve, reject) {
+            events$1.once('connect', function () {
+                resolve(events$1);
+            });
+            events$1.once('connect_error', function () {
+                reject();
+                events$1.close();
+            });
+        });
+    };
+    Api.prototype.getEvents = function (workspaceId, options) {
+        if (options === void 0) { options = {}; }
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var query, events;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        query = QueryString__default["default"].stringify(options);
+                        return [4 /*yield*/, this.get("/workspaces/".concat(workspaceId, "/events").concat(query && "?".concat(query)))];
+                    case 1:
+                        events = (_a.sent()).result.events;
+                        return [2 /*return*/, events.map(function (_a) {
+                                var createdAt = _a.createdAt, event = _tslib.__rest(_a, ["createdAt"]);
+                                return (_tslib.__assign(_tslib.__assign({}, event), { createdAt: new Date(createdAt) }));
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, []];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Api.prototype.postEvents = function (workspaceId, events) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.post("/workspaces/".concat(workspaceId, "/events"), {
+                                events: events,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Api.prototype.getPermissions = function (subjectType, subjectId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get("/".concat(subjectType, "/").concat(subjectId, "/permissions"))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.addPermissions = function (subjectType, subjectId, permissions) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post("/".concat(subjectType, "/").concat(subjectId, "/permissions"), permissions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.deletePermissions = function (subjectType, subjectId, userEmail) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.delete("/".concat(subjectType, "/").concat(subjectId, "/permissions/").concat(userEmail))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.getApps = function (_a) {
+        var query = _a.query, page = _a.page, limit = _a.limit, workspaceId = _a.workspaceId;
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var params;
+            return _tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = new URLSearchParams(utils.removedUndefinedProperties({
+                            text: "".concat(query || ''),
+                            page: "".concat(page || ''),
+                            limit: "".concat(limit || ''),
+                            workspaceId: "".concat(workspaceId || ''),
+                        }, true));
+                        return [4 /*yield*/, this.get("/apps?".concat(params.toString()))];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.installApp = function (workspaceId, body) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post("/workspaces/".concat(workspaceId, "/apps"), body)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.updateApp = function (workspaceId, slug, body) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.patch("/workspaces/".concat(workspaceId, "/apps/").concat(slug), body)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.uninstallApp = function (workspaceId, slug) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.delete("/workspaces/".concat(workspaceId, "/apps/").concat(slug))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.publishApp = function (body) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.post("/apps", body)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.listAppInstances = function (workspaceId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get("/workspaces/".concat(workspaceId, "/apps"))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.fetchImports = function (workspaceId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get("/workspaces/".concat(workspaceId, "/apps"))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Api.prototype.getAppConfig = function (workspaceId, slug) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var config;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get("/workspaces/".concat(workspaceId, "/apps/").concat(slug, "/config"))];
+                    case 1:
+                        config = _a.sent();
+                        return [2 /*return*/, config];
+                }
+            });
+        });
+    };
+    Api.prototype.updateAppConfig = function (workspaceId, slug, config) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.patch("/workspaces/".concat(workspaceId, "/apps/").concat(slug, "/config"), _tslib.__assign({}, config))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, config];
+                }
+            });
+        });
+    };
+    Api.prototype.uploadFiles = function (files, workspaceId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            function dataURItoBlob(dataURI) {
+                // convert base64/URLEncoded data component to raw binary data held in a string
+                var byteString;
+                if (dataURI.split(',')[0].indexOf('base64') >= 0)
+                    byteString = atob(dataURI.split(',')[1]);
+                else
+                    byteString = unescape(dataURI.split(',')[1]);
+                // separate out the mime component
+                var metadata = dataURI
+                    .split(';')
+                    .filter(function (v, k, all) { return k < all.length - 1; })
+                    .map(function (v) { return v.split(/:/); });
+                var _a = metadata.find(function (_a) {
+                    var k = _a[0]; _a[1];
+                    return k === 'data';
+                }) || [], _b = _a[1], mimeString = _b === void 0 ? '' : _b;
+                var _c = mimeString.split(/\//), ext = _c[1];
+                var _d = metadata.find(function (_a) {
+                    var k = _a[0]; _a[1];
+                    return k === 'filename';
+                }) || [], _e = _d[1], fileName = _e === void 0 ? "file.".concat(ext) : _e;
+                // write the bytes of the string to a typed array
+                var ia = new Uint8Array(byteString.length);
+                for (var i = 0; i < byteString.length; i++) {
+                    ia[i] = byteString.charCodeAt(i);
+                }
+                return [new Blob([ia], { type: mimeString }), fileName];
+            }
+            var formData;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        formData = new FormData();
+                        (Array.isArray(files) ? files : [files]).forEach(function (file) {
+                            formData.append.apply(formData, _tslib.__spreadArray(['file'], dataURItoBlob(file)));
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this._fetch("/workspaces/".concat(workspaceId, "/files"), {
+                                method: 'POST',
+                                body: formData,
+                            })];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, []];
+                }
+            });
+        });
+    };
+    Api.prototype.replaceAllImagesData = function (original, workspaceId) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var key, toUpload, searchImages, searching, uploaded, replaced;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        key = '…uploading-';
+                        toUpload = [];
+                        searchImages = function (mayHaveImage, uploaded) {
+                            switch (typeof mayHaveImage) {
+                                case 'string':
+                                    if (uploaded && mayHaveImage.match(key)) {
+                                        // Replace with url
+                                        var _a = mayHaveImage.split(key), index = _a[1];
+                                        return uploaded[+index];
+                                    }
+                                    if (mayHaveImage.match(/^data:/)) {
+                                        toUpload.push(mayHaveImage);
+                                        return "".concat(key).concat(toUpload.length - 1);
+                                    }
+                                    return mayHaveImage;
+                                case 'object':
+                                    var isArray = Array.isArray(mayHaveImage);
+                                    var withImagesUrl = isArray
+                                        ? _tslib.__spreadArray([], mayHaveImage) : _tslib.__assign({}, mayHaveImage);
+                                    for (var _i = 0, _b = Object.keys(withImagesUrl); _i < _b.length; _i++) {
+                                        var key_1 = _b[_i];
+                                        withImagesUrl[key_1] = searchImages(withImagesUrl[key_1], uploaded);
+                                    }
+                                    return withImagesUrl;
+                                default:
+                                    return mayHaveImage;
+                            }
+                        };
+                        searching = searchImages(original);
+                        if (toUpload.length === 0)
+                            return [2 /*return*/, original];
+                        return [4 /*yield*/, this.uploadFiles(toUpload, workspaceId)];
+                    case 1:
+                        uploaded = _a.sent();
+                        replaced = searchImages(searching, uploaded.map(function (_a) {
+                            var url = _a.url;
+                            return url;
+                        }));
+                        return [2 /*return*/, replaced];
+                }
+            });
+        });
+    };
+    Api.prototype.callAutomation = function (workspaceId, automation) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, this._fetch("/workspaces/".concat(workspaceId, "/webhooks/").concat(automation))];
+            });
+        });
+    };
+    return Api;
+}(fetcher.Fetcher));
+var api = new Api('https://api.eda.prisme.ai');
+
+exports.Api = Api;
+exports["default"] = api;

package/dist/sdk/lib/events.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var io = require('socket.io-client');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var io__default = /*#__PURE__*/_interopDefaultLegacy(io);
+
+var Events = /** @class */ (function () {
+    function Events(workspaceId, token, apiHost) {
+        if (apiHost === void 0) { apiHost = 'https://api.eda.prisme.ai'; }
+        this.workspaceId = workspaceId;
+        this.client = io__default["default"]("".concat(apiHost, "/workspaces/").concat(workspaceId, "/events"), {
+            extraHeaders: {
+                'x-prismeai-session-token': token,
+            },
+        });
+    }
+    Object.defineProperty(Events.prototype, "socket", {
+        get: function () {
+            return this.client;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Events.prototype.destroy = function () {
+        var _this = this;
+        this.workspaceId = '';
+        if (this.client.connected) {
+            this.client.disconnect();
+            return;
+        }
+        this.client.once('connect', function () {
+            _this.client.disconnect();
+        });
+    };
+    Events.prototype.all = function (listener) {
+        var _this = this;
+        this.client.onAny(listener);
+        return function () { return _this.client.offAny(listener); };
+    };
+    Events.prototype.on = function (ev, listener) {
+        var _this = this;
+        this.client.on(ev, listener);
+        return function () { return _this.client.off(ev, listener); };
+    };
+    Events.prototype.emit = function (event, payload) {
+        this.client.emit('event', {
+            type: event,
+            payload: payload,
+        });
+    };
+    Events.prototype.once = function (ev, listener) {
+        this.client.once(ev, listener);
+    };
+    Events.prototype.close = function () {
+        this.client.close();
+    };
+    return Events;
+}());
+
+exports.Events = Events;
+exports["default"] = Events;