@prisme.ai/sdk 1.0.1 → 1.0.2

package/lib/ImportProcessing.ts

@@ -0,0 +1,22 @@
+export type ImportProcessing = {
+  processing?: boolean;
+  message?: string;
+};
+export class ImportProcessingError extends Error {
+  error: ImportProcessing;
+  constructor(error: ImportProcessing) {
+    super();
+    this.error = error;
+  }
+}
+export type ImportSuccess = {
+  createdWorkspaceIds?: string[];
+  updatedWorkspaceIds?: string[];
+  imported: string[];
+  errors?: {
+    [name: string]: any;
+  }[];
+  workspace?: Prismeai.DSULReadOnly;
+  publishedApps?: Prismeai.App[];
+  deleted?: string[];
+};

package/lib/api.test.ts

@@ -47,11 +47,7 @@ it('should call /login/anonymous', async () => {
   const api = new Api({ host: '/fake/' });
   api.post = jest.fn();
   const user = await api.createAnonymousSession();
-  expect(api.post).toHaveBeenCalledWith(
-    '/login/anonymous',
-    {},
-    { credentials: 'omit' }
-  );
+  expect(api.post).toHaveBeenCalledWith('/login/anonymous');
   expect(api.user).toBe(user);
 });
 
@@ -706,6 +702,25 @@ it('should call automation', () => {
   );
 });
 
+it('should get automation from url', () => {
+  api.host = 'https://host.com';
+  expect(api.getAutomationFromUrl('13234', 'https://www.prisme.ai')).toBe(
+    false
+  );
+  expect(
+    api.getAutomationFromUrl(
+      '1234',
+      'https://host.com/workspaces/1234/webhooks/endpoint'
+    )
+  ).toBe('endpoint');
+  expect(
+    api.getAutomationFromUrl(
+      '1235',
+      'https://host.com/workspaces/1234/webhooks/endpoint'
+    )
+  ).toBe(false);
+});
+
 it('should get workspace usage', () => {
   const api = new Api({ host: '/fake/' });
   const get: jest.Mock = (api.get = jest.fn((): any => {}));

package/lib/api.ts

@@ -7,6 +7,11 @@ import { removedUndefinedProperties } from './utils';
 import WorkspacesEndpoint from './endpoints/workspaces';
 import ApiError from './ApiError';
 import UsersEndpoint from './endpoints/users';
+import {
+  ImportProcessing,
+  ImportProcessingError,
+  ImportSuccess,
+} from './ImportProcessing';
 
 interface PageWithMetadata extends Prismeai.Page {
   createdAt: string;
@@ -34,6 +39,9 @@ export interface ApiOptions {
     clientIdHeader?: string;
     redirectUri: string;
   };
+  websockets?: {
+    transports?: string[];
+  };
 }
 
 export interface AccessToken {
@@ -91,6 +99,10 @@ export class Api extends Fetcher {
         redirectUri: 'http://studio.local.prisme.ai:3000/signin',
         ...opts.oidc,
       },
+      websockets: {
+        ...opts.websockets,
+        transports: opts.websockets?.transports || ['polling', 'websocket'],
+      },
     };
   }
 
@@ -195,13 +207,7 @@ export class Api extends Fetcher {
       Prismeai.User & {
         token: string;
       }
-    >(
-      '/login/anonymous',
-      {},
-      {
-        credentials: 'omit',
-      }
-    );
+    >('/login/anonymous');
     this._user = user;
     return user;
   }
@@ -217,13 +223,19 @@ export class Api extends Fetcher {
       token: string;
     }
   > {
-    return await this.post('/signup', {
-      email: email,
-      password,
-      firstName,
-      lastName,
-      language,
-    });
+    return await this.post(
+      '/signup',
+      {
+        email: email,
+        password,
+        firstName,
+        lastName,
+        language,
+      },
+      {
+        credentials: 'omit',
+      }
+    );
   }
 
   getSignoutURL(redirectUri?: string) {
@@ -259,7 +271,7 @@ export class Api extends Fetcher {
 
   // Workspaces
   async getWorkspaces(): Promise<Workspace[]> {
-    return await this.get('/workspaces?limit=600');
+    return await this.get('/workspaces?limit=2000');
   }
 
   async getWorkspace(
@@ -287,14 +299,41 @@ export class Api extends Fetcher {
     return await this.get(`/workspaces/${id}/security/roles`);
   }
 
-  async createWorkspace(name: string): Promise<Workspace> {
-    return await this.post('/workspaces', { name });
+  async getWorkspaceSecrets(
+    id: string
+  ): Promise<Fetched<PrismeaiAPI.GetWorkspaceSecrets.Responses.$200>> {
+    return await this.get(`/workspaces/${id}/security/secrets`);
+  }
+
+  async updateWorkspaceSecrets(
+    id: string,
+    newSecrets: any
+  ): Promise<Workspace> {
+    return await this.patch(`/workspaces/${id}/security/secrets`, {
+      ...newSecrets,
+    });
+  }
+
+  async deleteWorkspaceSecrets(
+    id: string,
+    secretName: string
+  ): Promise<Workspace> {
+    return await this.delete(
+      `/workspaces/${id}/security/secrets/${secretName}`
+    );
+  }
+
+  async createWorkspace(
+    newWorkspace: Partial<Prismeai.Workspace>
+  ): Promise<Workspace> {
+    return await this.post('/workspaces', newWorkspace);
   }
 
   async duplicateWorkspace({ id }: { id: string }): Promise<Workspace | null> {
     return await this.post(`/workspaces/${id}/versions/current/duplicate`, {});
   }
 
+  // @deprecated. Use api.workspaces(id).update() instead
   async updateWorkspace(
     workspace: Prismeai.DSULPatch
   ): Promise<Fetched<PrismeaiAPI.UpdateWorkspace.Responses.$200> | null> {
@@ -305,6 +344,7 @@ export class Api extends Fetcher {
     );
   }
 
+  // @deprecated. Use api.workspaces(id).delete() instead
   async deleteWorkspace(workspaceId: Workspace['id']): Promise<Workspace> {
     return await this.delete(`/workspaces/${workspaceId}`);
   }
@@ -366,7 +406,9 @@ export class Api extends Fetcher {
     automationSlug: string
   ): Promise<Fetched<PrismeaiAPI.GetAutomation.Responses.$200>> {
     return await this.get(
-      `/workspaces/${workspaceId}/automations/${automationSlug}`
+      `/workspaces/${workspaceId}/automations/${encodeURIComponent(
+        automationSlug
+      )}`
     );
   }
 
@@ -385,13 +427,15 @@ export class Api extends Fetcher {
     automation: Prismeai.Automation
   ): Promise<Fetched<Prismeai.Automation & { slug: string }>> {
     return await this.patch(
-      `/workspaces/${workspaceId}/automations/${slug}`,
+      `/workspaces/${workspaceId}/automations/${encodeURIComponent(slug)}`,
       await this.replaceAllImagesData(automation, workspaceId)
     );
   }
 
   async deleteAutomation(workspaceId: string, slug: string): Promise<string> {
-    return await this.delete(`/workspaces/${workspaceId}/automations/${slug}`);
+    return await this.delete(
+      `/workspaces/${workspaceId}/automations/${encodeURIComponent(slug)}`
+    );
   }
 
   // Pages
@@ -471,6 +515,7 @@ export class Api extends Fetcher {
     if (filters && filters['source.sessionId'] === true) {
       if (this.sessionId) {
         filters['source.sessionId'] = this.sessionId;
+        filters['target.userTopic'] = ''; // We do not want to receive userTopics emitted by ourself for this session listener
       } else {
         delete filters['source.sessionId'];
       }
@@ -483,6 +528,7 @@ export class Api extends Fetcher {
       apiHost: this.host,
       filters,
       api: this,
+      transports: this.opts?.websockets?.transports,
     });
     return new Promise((resolve, reject) => {
       const off = events.once('connect_error', () => {
@@ -590,7 +636,6 @@ export class Api extends Fetcher {
           {
             error: 'CollaboratorNotFound',
             message: 'This user does not exist',
-            details: { email },
           },
           404
         );
@@ -645,6 +690,14 @@ export class Api extends Fetcher {
     return await this.get(`/apps?${params.toString()}`);
   }
 
+  async getApp({
+    slug = '',
+  }: {
+    slug?: PrismeaiAPI.GetApp.PathParameters['appSlug'];
+  }): Promise<Fetched<PrismeaiAPI.GetApp.Responses.$200>> {
+    return await this.get(`/apps/${encodeURIComponent(slug)}`);
+  }
+
   async installApp(
     workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'],
     body: PrismeaiAPI.InstallAppInstance.RequestBody
@@ -673,6 +726,7 @@ export class Api extends Fetcher {
     return await this.post(`/apps`, body);
   }
 
+  // @deprecated. Use api.workspaces(id).listAppInstances())
   async listAppInstances(
     workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']
   ): Promise<Fetched<PrismeaiAPI.ListAppInstances.Responses.$200>> {
@@ -720,13 +774,31 @@ export class Api extends Fetcher {
     return response;
   }
 
-  async uploadFiles(files: string | string[], workspaceId: string) {
+  // @deprecated. Use api.workspaces(id).uploadFiles()
+  async uploadFiles(
+    files: string | string[],
+    workspaceId: string,
+    opts?: {
+      expiresAfter?: number;
+      public?: boolean;
+      shareToken?: boolean;
+    }
+  ) {
     const formData = new FormData();
     (Array.isArray(files) ? files : [files]).forEach((file) => {
       try {
         formData.append('file', ...dataURItoBlob(file));
       } catch {}
     });
+    if (opts?.expiresAfter) {
+      formData.append('expiresAfter', `${opts?.expiresAfter}`);
+    }
+    if (typeof opts?.public === 'boolean') {
+      formData.append('public', `${opts?.public}`);
+    }
+    if (typeof opts?.shareToken === 'boolean') {
+      formData.append('shareToken', `${opts?.shareToken}`);
+    }
     try {
       return await this._fetch<PrismeaiAPI.UploadFile.Responses.$200>(
         `/workspaces/${workspaceId}/files`,
@@ -783,6 +855,13 @@ export class Api extends Fetcher {
     return replaced;
   }
 
+  getAutomationFromUrl(workspaceId: string, url: string) {
+    const match = url.match(
+      `${this.host}/workspaces/${workspaceId}/webhooks\/(.*$)`
+    );
+    return match ? match[1] : false;
+  }
+
   async callAutomation(
     workspaceId: string,
     automation: string,
@@ -808,6 +887,7 @@ export class Api extends Fetcher {
     });
   }
 
+  // @deprecated. Use api.workspaces(id).getUsage())
   async getWorkspaceUsage(
     workspaceId: PrismeaiAPI.WorkspaceUsage.Parameters.WorkspaceId,
     {
@@ -834,24 +914,22 @@ export class Api extends Fetcher {
     return this.get(`/workspaces/${workspaceId}/usage?${params.toString()}`);
   }
 
-  async importArchive(
-    archive: File
-  ): Promise<PrismeaiAPI.ImportNewWorkspace.Responses.$200> {
+  async importArchive(archive: File): Promise<ImportSuccess> {
     return new Promise((resolve) => {
       const fileReader = new FileReader();
       fileReader.addEventListener('load', async ({ target }) => {
         const file = target?.result as string;
         const formData = new FormData();
         formData.append('archive', ...dataURItoBlob(file));
-        resolve(
-          await this._fetch<PrismeaiAPI.ImportNewWorkspace.Responses.$200>(
-            `/workspaces/import`,
-            {
-              method: 'POST',
-              body: formData,
-            }
-          )
+
+        const result = await this.post<ImportProcessing | ImportSuccess>(
+          `/workspaces/import`,
+          formData
         );
+        if ((result as ImportProcessing).processing) {
+          throw new ImportProcessingError(result as ImportProcessing);
+        }
+        resolve(result as ImportSuccess);
       });
       fileReader.readAsDataURL(archive);
     });

package/lib/endpoints/users.ts

@@ -1,4 +1,5 @@
 import { Api } from '../api';
+import { dataURItoBlob, isDataURL } from '../utils';
 
 export class UsersEndpoint {
   private id: string;
@@ -9,13 +10,48 @@ export class UsersEndpoint {
     this.api = api;
   }
 
-  async setMeta(k: string, v: any) {
-    await this.api.post(`/user/meta`, {
+  async update(
+    data: Partial<Prismeai.User>
+  ): Promise<PrismeaiAPI.PatchUser.Responses.$200> {
+    if (isDataURL(data.photo)) {
+      await this.updatePhoto(data.photo);
+      delete data.photo;
+    }
+    return await this.api.patch('/user', data);
+  }
+
+  async updatePhoto(
+    photo: string
+  ): Promise<PrismeaiAPI.PostUserPhoto.Responses.$200> {
+    if (!isDataURL(photo)) {
+      throw new Error('Photo must be a dataurl file');
+    }
+    const formData = new FormData();
+    formData.append('photo', ...dataURItoBlob(photo));
+
+    return await this.api.post<PrismeaiAPI.PostUserPhoto.Responses.$200>(
+      `/user/photo`,
+      formData
+    );
+  }
+
+  async setMeta(
+    k: string,
+    v: any
+  ): Promise<PrismeaiAPI.SetMeta.Responses.$200> {
+    return await this.api.post(`/user/meta`, {
       [k]: v,
     });
   }
-  async deleteMeta(k: string) {
-    await this.api.delete(`/user/meta/${k}`);
+  async deleteMeta(k: string): Promise<PrismeaiAPI.DeleteMeta.Responses.$200> {
+    return await this.api.delete(`/user/meta/${k}`);
+  }
+
+  async sendDeleteValidation() {
+    return await this.api.delete(`/user`);
+  }
+  async delete(token?: string) {
+    return await this.api.delete(`/users/${this.id}?token=${token}`);
   }
 }
 

package/lib/endpoints/workspaces.ts

@@ -1,4 +1,11 @@
 import { Api } from '../api';
+import { Fetched } from '../fetcher';
+import {
+  ImportProcessing,
+  ImportProcessingError,
+  ImportSuccess,
+} from '../ImportProcessing';
+import { dataURItoBlob, removedUndefinedProperties } from '../utils';
 import WorkspacesVersionsEndpoint from './workspacesVersions';
 
 export class WorkspacesEndpoint {
@@ -13,6 +20,102 @@ export class WorkspacesEndpoint {
   get versions() {
     return new WorkspacesVersionsEndpoint(this.id, this.api);
   }
+
+  async update(
+    workspace: Prismeai.DSULPatch
+  ): Promise<Fetched<PrismeaiAPI.UpdateWorkspace.Responses.$200> | null> {
+    return await this.api.patch(
+      `/workspaces/${this.id}`,
+      await this.api.replaceAllImagesData(workspace, this.id)
+    );
+  }
+
+  async delete(): Promise<PrismeaiAPI.DeleteWorkspace.Responses.$200> {
+    return await this.api.delete(`/workspaces/${this.id}`);
+  }
+
+  async uploadFiles(
+    files: string | string[],
+    opts?: {
+      expiresAfter?: number;
+      public?: boolean;
+      shareToken?: boolean;
+    }
+  ) {
+    const formData = new FormData();
+    (Array.isArray(files) ? files : [files]).forEach((file) => {
+      try {
+        formData.append('file', ...dataURItoBlob(file));
+      } catch {}
+    });
+    if (opts?.expiresAfter) {
+      formData.append('expiresAfter', `${opts?.expiresAfter}`);
+    }
+    if (typeof opts?.public === 'boolean') {
+      formData.append('public', `${opts?.public}`);
+    }
+    if (typeof opts?.shareToken === 'boolean') {
+      formData.append('shareToken', `${opts?.shareToken}`);
+    }
+    try {
+      return await this.api.post<PrismeaiAPI.UploadFile.Responses.$200>(
+        `/workspaces/${this.id}/files`,
+        formData
+      );
+    } catch (e) {
+      console.error(e);
+    }
+    return [];
+  }
+
+  async listAppInstances(): Promise<
+    Fetched<PrismeaiAPI.ListAppInstances.Responses.$200>
+  > {
+    return await this.api.get(`/workspaces/${this.id}/apps`);
+  }
+
+  async getUsage({
+    afterDate,
+    beforeDate,
+    details,
+  }: {
+    afterDate?: PrismeaiAPI.WorkspaceUsage.Parameters.AfterDate;
+    beforeDate?: PrismeaiAPI.WorkspaceUsage.Parameters.BeforeDate;
+    details?: PrismeaiAPI.WorkspaceUsage.Parameters.Details;
+  } = {}): Promise<Fetched<PrismeaiAPI.WorkspaceUsage.Responses.$200>> {
+    const params = new URLSearchParams(
+      removedUndefinedProperties(
+        {
+          afterDate: `${afterDate || ''}`,
+          beforeDate: `${beforeDate || ''}`,
+          details: `${details || ''}`,
+        },
+        true
+      )
+    );
+
+    return this.api.get(`/workspaces/${this.id}/usage?${params.toString()}`);
+  }
+
+  async importArchive(archive: File): Promise<ImportSuccess> {
+    return new Promise((resolve) => {
+      const fileReader = new FileReader();
+      fileReader.addEventListener('load', async ({ target }) => {
+        const file = target?.result as string;
+        const formData = new FormData();
+        formData.append('archive', ...dataURItoBlob(file));
+        const result = await this.api.post<ImportProcessing | ImportSuccess>(
+          `/workspaces/${this.id}/import`,
+          formData
+        );
+        if ((result as ImportProcessing).processing) {
+          throw new ImportProcessingError(result as ImportProcessing);
+        }
+        resolve(result as ImportSuccess);
+      });
+      fileReader.readAsDataURL(archive);
+    });
+  }
 }
 
 export default WorkspacesEndpoint;

package/lib/endpoints/workspacesVersions.ts

@@ -10,24 +10,28 @@ export class WorkspacesVersionsEndpoint {
   }
 
   create(version?: PrismeaiAPI.PublishWorkspaceVersion.RequestBody) {
-    this.api.post(`/workspaces/${this.workspaceId}/versions`, version);
+    return this.api.post(`/workspaces/${this.workspaceId}/versions`, version);
   }
   rollback(
-    versionId: PrismeaiAPI.RollbackWorkspaceVersion.PathParameters['versionId']
+    versionId: PrismeaiAPI.PullWorkspaceVersion.PathParameters['versionId'],
+    opts?: PrismeaiAPI.PullWorkspaceVersion.RequestBody
   ) {
-    this.api.post(
-      `/workspaces/${this.workspaceId}/versions/${versionId}/rollback`
+    return this.api.post(
+      `/workspaces/${this.workspaceId}/versions/${versionId}/pull`,
+      opts
     );
   }
 
-  async export(version: PrismeaiAPI.ExportWorkspaceVersion.Parameters.VersionId = 'current') {
+  async export(
+    version: PrismeaiAPI.ExportWorkspaceVersion.Parameters.VersionId = 'current'
+  ) {
     const res = await this.api.prepareRequest(
-      `/workspaces/${this.workspaceId}/versions/${version}/export`, {
-        method: 'post'
+      `/workspaces/${this.workspaceId}/versions/${version}/export`,
+      {
+        method: 'post',
       }
-    )
+    );
     return new Blob([await res.arrayBuffer()], { type: 'application/zip' });
-    
   }
 }
 

package/lib/events.ts

@@ -20,6 +20,7 @@ export class Events {
   private listenedUserTopics: Map<string, string[]>;
   private listeners: Map<string, Function[]> = new Map();
   private lastReceivedEventDate: Date;
+  private socketId?: string;
 
   constructor({
     workspaceId,
@@ -29,6 +30,7 @@ export class Events {
     apiHost = 'https://api.eda.prisme.ai',
     filters,
     api,
+    transports,
   }: {
     workspaceId: string;
     token: string;
@@ -37,33 +39,62 @@ export class Events {
     apiHost?: string;
     filters?: Record<string, any>;
     api: Api;
+    transports?: string[];
   }) {
     this.workspaceId = workspaceId;
     const queryString = new URLSearchParams(filters || {}).toString();
     const fullQueryString = queryString ? `?${queryString}` : '';
     const extraHeaders: any = token
       ? {
-          Authorization: `Bearer ${token}`,
+          authorization: `Bearer ${token}`,
         }
       : { 'x-prismeai-token': legacyToken };
     this.lastReceivedEventDate = new Date();
     if (apiKey) {
       extraHeaders['x-prismeai-api-key'] = apiKey;
     }
+    this.filters = [filters || {}];
+    this.listenedUserTopics = new Map();
 
     this.client = io(
       `${apiHost}/workspaces/${workspaceId}/events${fullQueryString}`,
       {
         extraHeaders,
-        withCredentials: true,
+        withCredentials: !extraHeaders.authorization,
+        transports: transports || ['polling', 'websocket'],
+        auth: (cb) => {
+          cb({
+            // Browser websockets cannot send extraHeaders, so we use socketio-client auth instead
+            extraHeaders:
+              transports && transports[0] === 'websocket' ? extraHeaders : {},
+
+            filters: {
+              payloadQuery: this.filters,
+            },
+
+            reuseSocketId: this.socketId,
+          });
+        },
       }
     );
 
+    this.client.on('connect_error', (err) => {
+      console.error(`Failed websocket connection : `, err);
+      // revert to classic upgrade
+      this.client.io.opts.transports = ['polling', 'websocket'];
+    });
+    this.client.on('error', (err) => {
+      this.client.io.opts.transports = ['polling', 'websocket'];
+    });
+
     const onConnect = () => {
-      // Reset last filters
-      this.updateFilters({
-        payloadQuery: this.filters,
-      });
+      // First connection
+      if (!this.socketId) {
+        this.socketId = this.client.id;
+        return;
+      }
+
+      // Retrieve lost history on reconnection
       setTimeout(async () => {
         const events = await api.getEvents(workspaceId, {
           ...this.filters[this.filters.length - 1],
@@ -76,16 +107,23 @@ export class Events {
         });
       }, 2000);
     };
+    this.client.on('connect', onConnect);
+
     this.client.on('disconnect', () => {
       if (!this.lastReceivedEventDate) {
         this.lastReceivedEventDate = new Date();
       }
+      // Make sure we reconnect with current filters & socketId
+      this.client.auth = {
+        ...this.client.auth,
+        filters: {
+          payloadQuery: this.filters,
+        },
+        reuseSocketId: this.socketId,
+      };
       this.client.off('connect', onConnect);
       this.client.on('connect', onConnect);
     });
-
-    this.filters = [filters || {}];
-    this.listenedUserTopics = new Map();
   }
 
   get socket() {
@@ -105,12 +143,16 @@ export class Events {
   }
 
   all(listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void) {
-    this.client.onAny((eventName: string, eventData: Prismeai.PrismeEvent) => {
+    const anyListener = (
+      eventName: string,
+      eventData: Prismeai.PrismeEvent
+    ) => {
       this.lastReceivedEventDate = new Date(eventData?.createdAt);
       return listener(eventName, eventData);
-    });
+    };
+    this.client.onAny(anyListener);
 
-    return () => this.client.offAny(listener);
+    return () => this.client.offAny(anyListener);
   }
 
   on(ev: string, listener: (eventData: Prismeai.PrismeEvent) => void) {