@prisme.ai/sdk 1.0.0 → 1.0.1

package/Readme.md

@@ -16,7 +16,9 @@ You can set a different host by instantiating the Api class:
 
 ```
 import { Api } from '@prisme.ai/sdk';
-const api = new Api('https://my.custom.host')
+const api = new Api({
+  host: 'https://my.custom.host'
+})
 ```
 
 You are able to call un authentified methods like signin or signup, but you'll need a valid token to call the other. Just set its property:

package/dist/lib/api.d.ts

@@ -1,7 +1,8 @@
-import Fetcher from './fetcher';
+import Fetcher, { Fetched } from './fetcher';
 import { Event, Workspace } from './types';
 import { Events } from './events';
 import WorkspacesEndpoint from './endpoints/workspaces';
+import UsersEndpoint from './endpoints/users';
 export type UserPermissions = {
     permissions: Prismeai.UserPermissions['permissions'];
     target: {
@@ -12,21 +13,57 @@ export type UserPermissions = {
         displayName?: string;
     };
 };
+export interface ApiOptions {
+    host: string;
+    oidc?: {
+        url: string;
+        clientId: string;
+        clientIdHeader?: string;
+        redirectUri: string;
+    };
+}
+export interface AccessToken {
+    access_token: string;
+    id_token: string;
+    scope: string;
+    expiresIn: number;
+    token_type: 'Bearer';
+}
+export interface InteractiveSignin {
+    interaction: string;
+    login: string;
+    password: string;
+    remember?: boolean;
+}
 export declare class Api extends Fetcher {
+    opts: Required<ApiOptions>;
     private sessionId?;
     private _user?;
-    get user(): Prismeai.User | undefined;
+    constructor(opts: ApiOptions);
+    get user(): (Prismeai.User & {
+        sessionId?: string | undefined;
+    }) | undefined;
     me(): Promise<any>;
-    signin(email: string, password: string): Promise<Prismeai.User & {
-        token: string;
+    clientId(): string;
+    getAuthorizationURL(overrideRedirectUri?: string, authParams?: {
+        max_age?: string;
+        acr_values?: string;
+    }, locale?: string | undefined): Promise<{
+        url: string;
+        codeVerifier: string;
+        clientId: string;
+    }>;
+    signin(body: InteractiveSignin): Promise<{
+        redirectTo: string;
     }>;
+    getToken(authorizationCode: string, codeVerifier: string, overrideRedirectUri?: string): Promise<AccessToken>;
     createAnonymousSession(): Promise<Prismeai.User & {
         token: string;
     }>;
     signup(email: string, password: string, firstName: string, lastName: string, language: string): Promise<Prismeai.User & {
         token: string;
     }>;
-    signout(): Promise<void>;
+    getSignoutURL(redirectUri?: string): string;
     sendValidationMail(email: string, language: string): Promise<unknown>;
     validateMail(token: string): Promise<unknown>;
     sendPasswordResetMail(email: string, language: string): Promise<unknown>;
@@ -34,30 +71,30 @@ export declare class Api extends Fetcher {
     getWorkspaces(): Promise<Workspace[]>;
     getWorkspace(id: string): Promise<PrismeaiAPI.GetWorkspace.Responses.$200>;
     getWorkspaceSecurity(id: string): Promise<PrismeaiAPI.GetSecurity.Responses.$200>;
-    updateWorkspaceSecurity(workspaceId: string, security: Prismeai.WorkspaceSecurity): Promise<PrismeaiAPI.UpdateSecurity.Responses.$200>;
-    getWorkspaceRoles(id: string): Promise<PrismeaiAPI.GetRoles.Responses.$200>;
+    updateWorkspaceSecurity(workspaceId: string, security: Prismeai.WorkspaceSecurity): Promise<Fetched<PrismeaiAPI.UpdateSecurity.Responses.$200>>;
+    getWorkspaceRoles(id: string): Promise<Fetched<PrismeaiAPI.GetRoles.Responses.$200>>;
     createWorkspace(name: string): Promise<Workspace>;
     duplicateWorkspace({ id }: {
         id: string;
     }): Promise<Workspace | null>;
-    updateWorkspace(workspace: Prismeai.DSULPatch): Promise<PrismeaiAPI.UpdateWorkspace.Responses.$200 | null>;
+    updateWorkspace(workspace: Prismeai.DSULPatch): Promise<Fetched<PrismeaiAPI.UpdateWorkspace.Responses.$200> | null>;
     deleteWorkspace(workspaceId: Workspace['id']): Promise<Workspace>;
     generateApiKey(workspaceId: Workspace['id'], events: string[], uploads?: string[]): Promise<string>;
     updateApiKey(workspaceId: Workspace['id'], apiKey: string, events: string[], uploads?: string[]): Promise<string>;
-    getAutomation(workspaceId: string, automationSlug: string): Promise<PrismeaiAPI.GetAutomation.Responses.$200>;
-    createAutomation(workspaceId: Workspace['id'], automation: Prismeai.Automation): Promise<Prismeai.Automation & {
+    getAutomation(workspaceId: string, automationSlug: string): Promise<Fetched<PrismeaiAPI.GetAutomation.Responses.$200>>;
+    createAutomation(workspaceId: Workspace['id'], automation: Prismeai.Automation): Promise<Fetched<Prismeai.Automation & {
         slug: string;
-    }>;
-    updateAutomation(workspaceId: string, slug: string, automation: Prismeai.Automation): Promise<Prismeai.Automation & {
+    }>>;
+    updateAutomation(workspaceId: string, slug: string, automation: Prismeai.Automation): Promise<Fetched<Prismeai.Automation & {
         slug: string;
-    }>;
+    }>>;
     deleteAutomation(workspaceId: string, slug: string): Promise<string>;
     getPages(workspaceId: NonNullable<Workspace['id']>): Promise<Prismeai.Page[]>;
-    getPage(workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId, pageSlug: PrismeaiAPI.GetPage.Parameters.Slug): Promise<Prismeai.DetailedPage>;
-    getPageBySlug(workspaceSlug: PrismeaiAPI.GetPageBySlug.Parameters.WorkspaceSlug, pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.PageSlug): Promise<Prismeai.DetailedPage>;
+    getPage(workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId, pageSlug: PrismeaiAPI.GetPage.Parameters.Slug): Promise<Fetched<Prismeai.DetailedPage>>;
+    getPageBySlug(workspaceSlug: PrismeaiAPI.GetPageBySlug.Parameters.WorkspaceSlug, pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.PageSlug): Promise<Fetched<Prismeai.DetailedPage>>;
     createPage(workspaceId: PrismeaiAPI.CreatePage.Parameters.WorkspaceId, page: PrismeaiAPI.CreatePage.RequestBody): Promise<Prismeai.Page>;
     updatePage(workspaceId: PrismeaiAPI.UpdatePage.Parameters.WorkspaceId, page: PrismeaiAPI.UpdatePage.RequestBody, prevSlug?: PrismeaiAPI.DeletePage.Parameters.Slug): Promise<Prismeai.Page>;
-    deletePage(workspaceId: PrismeaiAPI.DeletePage.Parameters.WorkspaceId, pageSlug: PrismeaiAPI.DeletePage.Parameters.Slug): Promise<PrismeaiAPI.DeletePage.Responses.$200>;
+    deletePage(workspaceId: PrismeaiAPI.DeletePage.Parameters.WorkspaceId, pageSlug: PrismeaiAPI.DeletePage.Parameters.Slug): Promise<Fetched<PrismeaiAPI.DeletePage.Responses.$200>>;
     streamEvents(workspaceId: string, filters?: Record<string, any>): Promise<Events>;
     getEvents(workspaceId: string, options?: Record<string, any>): Promise<Event<Date>[]>;
     postEvents(workspaceId: PrismeaiAPI.SendWorkspaceEvent.Parameters.WorkspaceId, events: PrismeaiAPI.SendWorkspaceEvent.RequestBody['events']): Promise<boolean>;
@@ -66,30 +103,37 @@ export declare class Api extends Fetcher {
         result: UserPermissions[];
     }>;
     addPermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, permissions: UserPermissions): Promise<UserPermissions>;
-    deletePermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, id: string): Promise<PrismeaiAPI.RevokePermissions.Responses.$200>;
+    deletePermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, id: string): Promise<Fetched<PrismeaiAPI.RevokePermissions.Responses.$200>>;
     getApps({ query, page, limit, workspaceId, }: {
         query?: PrismeaiAPI.SearchApps.QueryParameters['text'];
         page?: PrismeaiAPI.SearchApps.QueryParameters['page'];
         limit?: PrismeaiAPI.SearchApps.QueryParameters['limit'];
         workspaceId?: PrismeaiAPI.SearchApps.QueryParameters['workspaceId'];
-    }): Promise<PrismeaiAPI.SearchApps.Responses.$200>;
-    installApp(workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'], body: PrismeaiAPI.InstallAppInstance.RequestBody): Promise<PrismeaiAPI.InstallAppInstance.Responses.$200>;
-    updateApp(workspaceId: PrismeaiAPI.ConfigureAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug'], body: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200>;
-    uninstallApp(workspaceId: PrismeaiAPI.UninstallAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug']): Promise<PrismeaiAPI.UninstallAppInstance.Responses.$200>;
-    publishApp(body: PrismeaiAPI.PublishApp.RequestBody): Promise<PrismeaiAPI.PublishApp.Responses.$200>;
-    listAppInstances(workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']): Promise<PrismeaiAPI.ListAppInstances.Responses.$200>;
+    }): Promise<Fetched<PrismeaiAPI.SearchApps.Responses.$200>>;
+    installApp(workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'], body: PrismeaiAPI.InstallAppInstance.RequestBody): Promise<Fetched<PrismeaiAPI.InstallAppInstance.Responses.$200>>;
+    updateApp(workspaceId: PrismeaiAPI.ConfigureAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug'], body: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<Fetched<PrismeaiAPI.ConfigureAppInstance.Responses.$200>>;
+    uninstallApp(workspaceId: PrismeaiAPI.UninstallAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug']): Promise<Fetched<PrismeaiAPI.UninstallAppInstance.Responses.$200>>;
+    publishApp(body: PrismeaiAPI.PublishApp.RequestBody): Promise<Fetched<PrismeaiAPI.PublishApp.Responses.$200>>;
+    listAppInstances(workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']): Promise<Fetched<PrismeaiAPI.ListAppInstances.Responses.$200>>;
     getAppConfig<T>(workspaceId: PrismeaiAPI.GetAppInstanceConfig.Parameters.WorkspaceId, slug: PrismeaiAPI.GetAppInstanceConfig.Parameters.Slug): Promise<T>;
     updateAppConfig(workspaceId: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.WorkspaceId, slug: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.Slug, config: any): Promise<PrismeaiAPI.UpdateAppInstanceConfig.Responses.$200['config']>;
-    getAppInstance(workspaceId: string, slug: string): Promise<PrismeaiAPI.GetAppInstance.Responses.$200>;
-    saveAppInstance(workspaceId: PrismeaiAPI.ConfigureAppInstance.Parameters.WorkspaceId, slug: PrismeaiAPI.ConfigureAppInstance.Parameters.Slug, appInstance: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200>;
+    getAppInstance(workspaceId: string, slug: string): Promise<Fetched<PrismeaiAPI.GetAppInstance.Responses.$200>>;
+    saveAppInstance(workspaceId: PrismeaiAPI.ConfigureAppInstance.Parameters.WorkspaceId, slug: PrismeaiAPI.ConfigureAppInstance.Parameters.Slug, appInstance: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<Fetched<PrismeaiAPI.ConfigureAppInstance.Responses.$200>>;
     uploadFiles(files: string | string[], workspaceId: string): Promise<PrismeaiAPI.UploadFile.Responses.$200>;
     replaceAllImagesData(original: any, workspaceId: string): Promise<any>;
-    callAutomation(workspaceId: string, automation: string, params?: any): Promise<any>;
+    callAutomation(workspaceId: string, automation: string, params?: any): Promise<Fetched<any>>;
+    testAutomation({ workspaceId, automation, payload, }: {
+        workspaceId: string;
+        automation: string;
+        payload?: Record<string, any>;
+    }): Promise<Fetched<any>>;
     getWorkspaceUsage(workspaceId: PrismeaiAPI.WorkspaceUsage.Parameters.WorkspaceId, { afterDate, beforeDate, details, }?: {
         afterDate?: PrismeaiAPI.WorkspaceUsage.Parameters.AfterDate;
         beforeDate?: PrismeaiAPI.WorkspaceUsage.Parameters.BeforeDate;
         details?: PrismeaiAPI.WorkspaceUsage.Parameters.Details;
-    }): Promise<PrismeaiAPI.WorkspaceUsage.Responses.$200>;
+    }): Promise<Fetched<PrismeaiAPI.WorkspaceUsage.Responses.$200>>;
+    importArchive(archive: File): Promise<PrismeaiAPI.ImportNewWorkspace.Responses.$200>;
+    users(id?: string): UsersEndpoint;
     workspaces(id: string): WorkspacesEndpoint;
 }
 declare const _default: Api;

package/dist/lib/endpoints/users.d.ts

@@ -0,0 +1,9 @@
+import { Api } from '../api';
+export declare class UsersEndpoint {
+    private id;
+    private api;
+    constructor(id: string, api: Api);
+    setMeta(k: string, v: any): Promise<void>;
+    deleteMeta(k: string): Promise<void>;
+}
+export default UsersEndpoint;

package/dist/lib/events.d.ts

@@ -12,9 +12,11 @@ export declare class Events {
     private filters;
     private listenedUserTopics;
     private listeners;
-    constructor({ workspaceId, token, apiKey, apiHost, filters, api, }: {
+    private lastReceivedEventDate;
+    constructor({ workspaceId, token, legacyToken, apiKey, apiHost, filters, api, }: {
         workspaceId: string;
         token: string;
+        legacyToken?: string;
         apiKey?: string;
         apiHost?: string;
         filters?: Record<string, any>;

package/dist/lib/fetcher.d.ts

@@ -1,14 +1,21 @@
+export type Fetched<T> = T & {
+    headers?: Record<string, any>;
+};
 export declare class Fetcher {
     host: string;
     token: string | null;
+    legacyToken: string | null;
+    overwriteClientId?: string;
+    private clientIdHeader?;
     protected _apiKey: string | null;
     language: string | undefined;
-    constructor(host: string);
+    lastReceivedHeaders?: Record<string, any>;
+    constructor(host: string, clientIdHeader?: string);
     set apiKey(apiKey: string);
     prepareRequest(url: string, options?: RequestInit): Promise<Response>;
     protected _fetch<T>(url: string, options?: RequestInit): Promise<T>;
     get<T = any>(url: string): Promise<T>;
-    post<T>(url: string, body?: Record<string, any>): Promise<T>;
+    post<T>(url: string, body?: Record<string, any>, opts?: RequestInit): Promise<T>;
     put<T>(url: string, body: Record<string, any>): Promise<T>;
     patch<T>(url: string, body: Record<string, any>): Promise<T>;
     delete<T>(url: string): Promise<T>;

package/dist/sdk/lib/api.js

@@ -4,20 +4,55 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../_virtual/_tslib.js');
 var QueryString = require('qs');
+var pkceChallenge = require('pkce-challenge');
 var fetcher = require('./fetcher.js');
 var events = require('./events.js');
 var utils = require('./utils.js');
 var workspaces = require('./endpoints/workspaces.js');
 var ApiError = require('./ApiError.js');
+var users = require('./endpoints/users.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var QueryString__default = /*#__PURE__*/_interopDefaultLegacy(QueryString);
+var pkceChallenge__default = /*#__PURE__*/_interopDefaultLegacy(pkceChallenge);
 
+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 Api = /** @class */ (function (_super) {
     _tslib.__extends(Api, _super);
-    function Api() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    function Api(opts) {
+        var _this = this;
+        var _a;
+        _this = _super.call(this, opts.host, (_a = opts === null || opts === void 0 ? void 0 : opts.oidc) === null || _a === void 0 ? void 0 : _a.clientIdHeader) || this;
+        _this.opts = _tslib.__assign(_tslib.__assign({}, opts), { oidc: _tslib.__assign({ url: 'http://studio.local.prisme.ai:3001', clientId: 'local-client-id', redirectUri: 'http://studio.local.prisme.ai:3000/signin' }, opts.oidc) });
+        return _this;
     }
     Object.defineProperty(Api.prototype, "user", {
         get: function () {
@@ -41,19 +76,86 @@ var Api = /** @class */ (function (_super) {
             });
         });
     };
-    Api.prototype.signin = function (email, password) {
+    Api.prototype.clientId = function () {
+        var _a, _b;
+        return this.overwriteClientId || ((_b = (_a = this.opts) === null || _a === void 0 ? void 0 : _a.oidc) === null || _b === void 0 ? void 0 : _b.clientId);
+    };
+    Api.prototype.getAuthorizationURL = function (overrideRedirectUri, authParams, locale) {
+        var _a, _b;
+        if (locale === void 0) { locale = ((_a = window === null || window === void 0 ? void 0 : window.navigator) === null || _a === void 0 ? void 0 : _a.language)
+            ? window.navigator.language.substring(0, 2)
+            : undefined; }
         return _tslib.__awaiter(this, void 0, void 0, function () {
-            var user;
+            var url, clientId, _c, codeVerifier, codeChallenge;
+            return _tslib.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        url = new URL('/oidc/auth', this.opts.oidc.url);
+                        url.searchParams.set('response_type', 'code');
+                        url.searchParams.set('response_mode', 'query'); // Send the final authorization code as a query param to the redirect uri
+                        url.searchParams.set('redirect_uri', overrideRedirectUri || ((_b = this.opts.oidc) === null || _b === void 0 ? void 0 : _b.redirectUri) || '');
+                        url.searchParams.set('scope', 'openid profile email settings offline_access events:write events:read webhooks pages:read files:write files:read');
+                        clientId = this.clientId();
+                        url.searchParams.set('client_id', clientId);
+                        url.searchParams.set('code_challenge_method', 'S256');
+                        return [4 /*yield*/, pkceChallenge__default["default"](64)];
+                    case 1:
+                        _c = _d.sent(), codeVerifier = _c.code_verifier, codeChallenge = _c.code_challenge;
+                        url.searchParams.set('code_challenge', codeChallenge);
+                        if (locale) {
+                            url.searchParams.set('locale', locale);
+                        }
+                        Object.entries(authParams || {}).forEach(function (_a) {
+                            var k = _a[0], v = _a[1];
+                            url.searchParams.set(k, v);
+                        });
+                        return [2 /*return*/, {
+                                url: url.toString(),
+                                codeVerifier: codeVerifier,
+                                clientId: clientId,
+                            }];
+                }
+            });
+        });
+    };
+    Api.prototype.signin = function (body) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var url, redirectTo;
             return _tslib.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.post('/login', {
-                            email: email,
-                            password: password,
-                        })];
+                    case 0:
+                        url = new URL("/oidc/interaction/".concat(body.interaction, "/login"), this.opts.oidc.url);
+                        // Do not follow redirects as we need to get redirected from browser itself to save final token in local storage
+                        return [4 /*yield*/, this.post(url.toString(), new URLSearchParams(body), {
+                                redirect: 'manual',
+                            })];
                     case 1:
-                        user = _a.sent();
-                        this._user = user;
-                        return [2 /*return*/, user];
+                        // Do not follow redirects as we need to get redirected from browser itself to save final token in local storage
+                        _a.sent();
+                        redirectTo = new URL("/oidc/auth/".concat(body.interaction), this.opts.oidc.url);
+                        return [2 /*return*/, { redirectTo: redirectTo.toString() }];
+                }
+            });
+        });
+    };
+    Api.prototype.getToken = function (authorizationCode, codeVerifier, overrideRedirectUri) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var url, token;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.token = null;
+                        url = new URL('/oidc/token', this.opts.oidc.url);
+                        return [4 /*yield*/, this.post(url.toString(), new URLSearchParams({
+                                grant_type: 'authorization_code',
+                                code: authorizationCode,
+                                code_verifier: codeVerifier,
+                                client_id: this.clientId(),
+                                redirect_uri: overrideRedirectUri || this.opts.oidc.redirectUri,
+                            }))];
+                    case 1:
+                        token = _a.sent();
+                        return [2 /*return*/, token];
                 }
             });
         });
@@ -63,7 +165,9 @@ var Api = /** @class */ (function (_super) {
             var user;
             return _tslib.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.post('/login/anonymous')];
+                    case 0: return [4 /*yield*/, this.post('/login/anonymous', {}, {
+                            credentials: 'omit',
+                        })];
                     case 1:
                         user = _a.sent();
                         this._user = user;
@@ -88,18 +192,14 @@ var Api = /** @class */ (function (_super) {
             });
         });
     };
-    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*/];
-                }
-            });
-        });
+    Api.prototype.getSignoutURL = function (redirectUri) {
+        var params = new URLSearchParams();
+        params.set('client_id', this.clientId());
+        if (redirectUri) {
+            params.set('post_logout_redirect_uri', redirectUri);
+        }
+        var url = new URL("/oidc/session/end?".concat(params.toString()), this.opts.oidc.url);
+        return url.toString();
     };
     // Mail validation
     Api.prototype.sendValidationMail = function (email, language) {
@@ -441,6 +541,7 @@ var Api = /** @class */ (function (_super) {
         var events$1 = new events.Events({
             workspaceId: workspaceId,
             token: this.token || '',
+            legacyToken: this.legacyToken || '',
             apiKey: this._apiKey ? this._apiKey : undefined,
             apiHost: this.host,
             filters: filters,
@@ -696,34 +797,6 @@ var Api = /** @class */ (function (_super) {
     };
     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) {
@@ -807,6 +880,16 @@ var Api = /** @class */ (function (_super) {
             });
         });
     };
+    Api.prototype.testAutomation = function (_a) {
+        var workspaceId = _a.workspaceId, automation = _a.automation, payload = _a.payload;
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_b) {
+                return [2 /*return*/, this.post("/workspaces/".concat(workspaceId, "/test/").concat(automation), {
+                        payload: payload,
+                    })];
+            });
+        });
+    };
     Api.prototype.getWorkspaceUsage = function (workspaceId, _a) {
         var _b = _a === void 0 ? {} : _a, afterDate = _b.afterDate, beforeDate = _b.beforeDate, details = _b.details;
         return _tslib.__awaiter(this, void 0, void 0, function () {
@@ -821,12 +904,53 @@ var Api = /** @class */ (function (_super) {
             });
         });
     };
+    Api.prototype.importArchive = function (archive) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var fileReader = new FileReader();
+                        fileReader.addEventListener('load', function (_a) {
+                            var target = _a.target;
+                            return _tslib.__awaiter(_this, void 0, void 0, function () {
+                                var file, formData, _b;
+                                return _tslib.__generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            file = target === null || target === void 0 ? void 0 : target.result;
+                                            formData = new FormData();
+                                            formData.append.apply(formData, _tslib.__spreadArray(['archive'], dataURItoBlob(file)));
+                                            _b = resolve;
+                                            return [4 /*yield*/, this._fetch("/workspaces/import", {
+                                                    method: 'POST',
+                                                    body: formData,
+                                                })];
+                                        case 1:
+                                            _b.apply(void 0, [_c.sent()]);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            });
+                        });
+                        fileReader.readAsDataURL(archive);
+                    })];
+            });
+        });
+    };
+    Api.prototype.users = function (id) {
+        var _a;
+        if (id === void 0) { id = ((_a = this.user) === null || _a === void 0 ? void 0 : _a.id) || ''; }
+        if (!id) {
+            throw new Error();
+        }
+        return new users.UsersEndpoint(id, this);
+    };
     Api.prototype.workspaces = function (id) {
         return new workspaces.WorkspacesEndpoint(id, this);
     };
     return Api;
 }(fetcher.Fetcher));
-var api = new Api('https://api.eda.prisme.ai');
+var api = new Api({ host: 'https://api.eda.prisme.ai' });
 
 exports.Api = Api;
 exports["default"] = api;

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/events.js

@@ -11,15 +11,18 @@ var io__default = /*#__PURE__*/_interopDefaultLegacy(io);
 
 var Events = /** @class */ (function () {
     function Events(_a) {
-        var workspaceId = _a.workspaceId, token = _a.token, apiKey = _a.apiKey, _b = _a.apiHost, apiHost = _b === void 0 ? 'https://api.eda.prisme.ai' : _b, filters = _a.filters, api = _a.api;
+        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;
         var queryString = new URLSearchParams(filters || {}).toString();
         var fullQueryString = queryString ? "?".concat(queryString) : '';
-        var extraHeaders = {
-            'x-prismeai-token': token,
-        };
+        var extraHeaders = token
+            ? {
+                Authorization: "Bearer ".concat(token),
+            }
+            : { 'x-prismeai-token': legacyToken };
+        this.lastReceivedEventDate = new Date();
         if (apiKey) {
             extraHeaders['x-prismeai-api-key'] = apiKey;
         }
@@ -27,14 +30,17 @@ var Events = /** @class */ (function () {
             extraHeaders: extraHeaders,
             withCredentials: true,
         });
-        var lastConnectionTime = new Date();
         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: lastConnectionTime.toISOString() }))];
+                        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) {
@@ -48,7 +54,9 @@ var Events = /** @class */ (function () {
             }); }, 2000);
         };
         this.client.on('disconnect', function () {
-            lastConnectionTime = new Date();
+            if (!_this.lastReceivedEventDate) {
+                _this.lastReceivedEventDate = new Date();
+            }
             _this.client.off('connect', onConnect);
             _this.client.on('connect', onConnect);
         });
@@ -75,7 +83,10 @@ 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) {