@prisme.ai/sdk 0.0.2 → 1.0.1

package/dist/sdk/lib/endpoints/users.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.js');
+
+var UsersEndpoint = /** @class */ (function () {
+    function UsersEndpoint(id, api) {
+        this.id = id;
+        this.api = api;
+    }
+    UsersEndpoint.prototype.setMeta = function (k, v) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _a;
+            return _tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.api.post("/user/meta", (_a = {},
+                            _a[k] = v,
+                            _a))];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UsersEndpoint.prototype.deleteMeta = function (k) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.api.delete("/user/meta/".concat(k))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return UsersEndpoint;
+}());
+
+exports.UsersEndpoint = UsersEndpoint;
+exports["default"] = UsersEndpoint;

package/dist/sdk/lib/endpoints/workspaces.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var workspacesVersions = require('./workspacesVersions.js');
+
+var WorkspacesEndpoint = /** @class */ (function () {
+    function WorkspacesEndpoint(id, api) {
+        this.id = id;
+        this.api = api;
+    }
+    Object.defineProperty(WorkspacesEndpoint.prototype, "versions", {
+        get: function () {
+            return new workspacesVersions.WorkspacesVersionsEndpoint(this.id, this.api);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return WorkspacesEndpoint;
+}());
+
+exports.WorkspacesEndpoint = WorkspacesEndpoint;
+exports["default"] = WorkspacesEndpoint;

package/dist/sdk/lib/endpoints/workspacesVersions.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.js');
+
+var WorkspacesVersionsEndpoint = /** @class */ (function () {
+    function WorkspacesVersionsEndpoint(workspaceId, api) {
+        this.workspaceId = workspaceId;
+        this.api = api;
+    }
+    WorkspacesVersionsEndpoint.prototype.create = function (version) {
+        this.api.post("/workspaces/".concat(this.workspaceId, "/versions"), version);
+    };
+    WorkspacesVersionsEndpoint.prototype.rollback = function (versionId) {
+        this.api.post("/workspaces/".concat(this.workspaceId, "/versions/").concat(versionId, "/rollback"));
+    };
+    WorkspacesVersionsEndpoint.prototype.export = function (version) {
+        if (version === void 0) { version = 'current'; }
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var res, _a;
+            return _tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.api.prepareRequest("/workspaces/".concat(this.workspaceId, "/versions/").concat(version, "/export"), {
+                            method: 'post'
+                        })];
+                    case 1:
+                        res = _b.sent();
+                        _a = Blob.bind;
+                        return [4 /*yield*/, res.arrayBuffer()];
+                    case 2: return [2 /*return*/, new (_a.apply(Blob, [void 0, [_b.sent()], { type: 'application/zip' }]))()];
+                }
+            });
+        });
+    };
+    return WorkspacesVersionsEndpoint;
+}());
+
+exports.WorkspacesVersionsEndpoint = WorkspacesVersionsEndpoint;
+exports["default"] = WorkspacesVersionsEndpoint;

package/dist/sdk/lib/events.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _tslib = require('../../_virtual/_tslib.js');
 var io = require('socket.io-client');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -9,14 +10,58 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 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'; }
+    function Events(_a) {
+        var workspaceId = _a.workspaceId, token = _a.token, legacyToken = _a.legacyToken, apiKey = _a.apiKey, _b = _a.apiHost, apiHost = _b === void 0 ? 'https://api.eda.prisme.ai' : _b, filters = _a.filters, api = _a.api;
+        var _this = this;
+        this.listeners = new Map();
         this.workspaceId = workspaceId;
-        this.client = io__default["default"]("".concat(apiHost, "/workspaces/").concat(workspaceId, "/events"), {
-            extraHeaders: {
-                'x-prismeai-session-token': token,
-            },
+        var queryString = new URLSearchParams(filters || {}).toString();
+        var fullQueryString = queryString ? "?".concat(queryString) : '';
+        var extraHeaders = token
+            ? {
+                Authorization: "Bearer ".concat(token),
+            }
+            : { 'x-prismeai-token': legacyToken };
+        this.lastReceivedEventDate = new Date();
+        if (apiKey) {
+            extraHeaders['x-prismeai-api-key'] = apiKey;
+        }
+        this.client = io__default["default"]("".concat(apiHost, "/workspaces/").concat(workspaceId, "/events").concat(fullQueryString), {
+            extraHeaders: extraHeaders,
+            withCredentials: true,
         });
+        var onConnect = function () {
+            // Reset last filters
+            _this.updateFilters({
+                payloadQuery: _this.filters,
+            });
+            setTimeout(function () { return _tslib.__awaiter(_this, void 0, void 0, function () {
+                var events;
+                var _this = this;
+                return _tslib.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api.getEvents(workspaceId, _tslib.__assign(_tslib.__assign({}, this.filters[this.filters.length - 1]), { afterDate: this.lastReceivedEventDate.toISOString() }))];
+                        case 1:
+                            events = _a.sent();
+                            events.reverse().forEach(function (event) {
+                                (_this.listeners.get(event.type) || []).forEach(function (listener) {
+                                    return listener(event);
+                                });
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            }); }, 2000);
+        };
+        this.client.on('disconnect', function () {
+            if (!_this.lastReceivedEventDate) {
+                _this.lastReceivedEventDate = new Date();
+            }
+            _this.client.off('connect', onConnect);
+            _this.client.on('connect', onConnect);
+        });
+        this.filters = [filters || {}];
+        this.listenedUserTopics = new Map();
     }
     Object.defineProperty(Events.prototype, "socket", {
         get: function () {
@@ -38,22 +83,54 @@ var Events = /** @class */ (function () {
     };
     Events.prototype.all = function (listener) {
         var _this = this;
-        this.client.onAny(listener);
+        this.client.onAny(function (eventName, eventData) {
+            _this.lastReceivedEventDate = new Date(eventData === null || eventData === void 0 ? void 0 : eventData.createdAt);
+            return listener(eventName, eventData);
+        });
         return function () { return _this.client.offAny(listener); };
     };
     Events.prototype.on = function (ev, listener) {
         var _this = this;
+        this.listeners.set(ev, _tslib.__spreadArray(_tslib.__spreadArray([], (this.listeners.get(ev) || []), true), [listener]));
         this.client.on(ev, listener);
-        return function () { return _this.client.off(ev, listener); };
+        return function () {
+            _this.listeners.set(ev, (_this.listeners.get(ev) || []).filter(function (l) { return l !== listener; }));
+            _this.client.off(ev, listener);
+        };
     };
-    Events.prototype.emit = function (event, payload) {
+    Events.prototype.emit = function (event, payload, options) {
         this.client.emit('event', {
             type: event,
             payload: payload,
+            options: options,
         });
     };
+    Events.prototype.listenTopics = function (_a) {
+        var event = _a.event, topics = _a.topics;
+        topics = Array.isArray(topics) ? topics : [topics];
+        this.listenedUserTopics.set(event, topics);
+        this.filters = [
+            _tslib.__assign({}, this.filters[0]),
+            {
+                'target.userTopic': Array.from(this.listenedUserTopics).flatMap(function (_a) {
+                    _a[0]; var topics = _a[1];
+                    return topics;
+                }),
+            },
+        ];
+        this.updateFilters({
+            payloadQuery: this.filters,
+        });
+    };
+    Events.prototype.updateFilters = function (filters) {
+        this.client.emit('filters', filters);
+    };
     Events.prototype.once = function (ev, listener) {
+        var _this = this;
         this.client.once(ev, listener);
+        return function () {
+            _this.client.off(ev, listener);
+        };
     };
     Events.prototype.close = function () {
         this.client.close();

package/dist/sdk/lib/fetcher.js

@@ -14,29 +14,63 @@ var headersAsObject = function (headers) {
     }, {});
 };
 var Fetcher = /** @class */ (function () {
-    function Fetcher(host) {
+    function Fetcher(host, clientIdHeader) {
         this.token = null;
+        this.legacyToken = null;
+        this._apiKey = null;
         this.host = host;
+        this.clientIdHeader = clientIdHeader;
     }
+    Object.defineProperty(Fetcher.prototype, "apiKey", {
+        set: function (apiKey) {
+            this._apiKey = apiKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Fetcher.prototype.prepareRequest = function (url, options) {
+        if (options === void 0) { options = {}; }
+        var headers = new Headers(options.headers || {});
+        if (this.token && !headers.has('Authorization')) {
+            headers.append('Authorization', "Bearer ".concat(this.token));
+        }
+        else if (this.legacyToken && !headers.has('Authorization')) {
+            headers.append('x-prismeai-token', this.legacyToken);
+        }
+        if (this._apiKey && !headers.has('x-prismeai-apikey')) {
+            headers.append('x-prismeai-api-key', this._apiKey);
+        }
+        if (this.language) {
+            headers.append('accept-language', this.language);
+        }
+        if (options.body instanceof URLSearchParams) {
+            headers.set('Content-Type', 'application/x-www-form-urlencoded');
+        }
+        if ((!options.body || !(options.body instanceof FormData)) &&
+            !headers.has('Content-Type')) {
+            headers.append('Content-Type', 'application/json');
+        }
+        var fullUrl = url.startsWith('http://') || url.startsWith('https://')
+            ? url
+            : "".concat(this.host).concat(url);
+        return global.fetch(fullUrl, _tslib.__assign(_tslib.__assign({ credentials: 'include' }, options), { headers: headers }));
+    };
     Fetcher.prototype._fetch = function (url, options) {
         if (options === void 0) { options = {}; }
         return _tslib.__awaiter(this, void 0, void 0, function () {
-            var headers, res, error, _a, clone, response;
+            var res, error, _a, contentType, response, text;
             return _tslib.__generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0:
-                        headers = new Headers(options.headers || {});
-                        if (this.token && !headers.has('x-prismeai-session-token')) {
-                            headers.append('x-prismeai-session-token', this.token);
-                        }
-                        if ((!options.body || !(options.body instanceof FormData)) &&
-                            !headers.has('Content-Type')) {
-                            headers.append('Content-Type', 'application/json');
-                        }
-                        headers.append('Access-Control-Allow-Origin', '*');
-                        return [4 /*yield*/, global.fetch("".concat(this.host).concat(url), _tslib.__assign(_tslib.__assign({}, options), { headers: headers }))];
+                    case 0: return [4 /*yield*/, this.prepareRequest(url, options)];
                     case 1:
                         res = _b.sent();
+                        if (options.redirect === 'manual' && res.status === 0) {
+                            return [2 /*return*/, { redirected: true }];
+                        }
+                        this.lastReceivedHeaders = headersAsObject(res.headers);
+                        if (this.clientIdHeader && this.lastReceivedHeaders[this.clientIdHeader]) {
+                            this.overwriteClientId = this.lastReceivedHeaders[this.clientIdHeader];
+                        }
                         if (!!res.ok) return [3 /*break*/, 6];
                         error = void 0;
                         _b.label = 2;
@@ -53,10 +87,11 @@ var Fetcher = /** @class */ (function () {
                         return [3 /*break*/, 5];
                     case 5: throw error;
                     case 6:
-                        clone = res.clone();
+                        contentType = res.headers.get('content-type');
+                        if (!(contentType && contentType.includes('application/json'))) return [3 /*break*/, 10];
                         _b.label = 7;
                     case 7:
-                        _b.trys.push([7, 9, , 11]);
+                        _b.trys.push([7, 9, , 10]);
                         return [4 /*yield*/, res.json()];
                     case 8:
                         response = (_b.sent()) || {};
@@ -69,9 +104,17 @@ var Fetcher = /** @class */ (function () {
                         return [2 /*return*/, response];
                     case 9:
                         _b.sent();
-                        return [4 /*yield*/, clone.text()];
-                    case 10: return [2 /*return*/, (_b.sent())];
-                    case 11: return [2 /*return*/];
+                        return [2 /*return*/, {}];
+                    case 10: return [4 /*yield*/, res.text()];
+                    case 11:
+                        text = _b.sent();
+                        try {
+                            return [2 /*return*/, JSON.parse(text)];
+                        }
+                        catch (_c) {
+                            return [2 /*return*/, text];
+                        }
+                        return [2 /*return*/];
                 }
             });
         });
@@ -85,12 +128,23 @@ var Fetcher = /** @class */ (function () {
             });
         });
     };
-    Fetcher.prototype.post = function (url, body) {
+    Fetcher.prototype.post = function (url, body, opts) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, this._fetch(url, _tslib.__assign({ method: 'POST', body: body &&
+                            !(body instanceof FormData) &&
+                            !(body instanceof URLSearchParams)
+                            ? JSON.stringify(body)
+                            : body }, opts))];
+            });
+        });
+    };
+    Fetcher.prototype.put = function (url, body) {
         return _tslib.__awaiter(this, void 0, void 0, function () {
             return _tslib.__generator(this, function (_a) {
                 return [2 /*return*/, this._fetch(url, {
-                        method: 'POST',
-                        body: body && !(body instanceof FormData) ? JSON.stringify(body) : body,
+                        method: 'PUT',
+                        body: JSON.stringify(body),
                     })];
             });
         });