@prisme.ai/sdk 1.0.0 → 1.0.2

package/lib/endpoints/users.ts

@@ -0,0 +1,58 @@
+import { Api } from '../api';
+import { dataURItoBlob, isDataURL } from '../utils';
+
+export class UsersEndpoint {
+  private id: string;
+  private api: Api;
+
+  constructor(id: string, api: Api) {
+    this.id = id;
+    this.api = api;
+  }
+
+  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): 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}`);
+  }
+}
+
+export default UsersEndpoint;

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.test.ts

@@ -21,7 +21,7 @@ it('should connect to Websocket', () => {
     `https://api.eda.prisme.ai/workspaces/1/events`,
     {
       extraHeaders: {
-        'x-prismeai-token': 'abcde',
+        Authorization: 'Bearer abcde',
       },
       withCredentials: true,
     }
@@ -39,7 +39,7 @@ it('should connect to Websocket with apiKey', () => {
     `https://api.eda.prisme.ai/workspaces/1/events`,
     {
       extraHeaders: {
-        'x-prismeai-token': 'abcde',
+        Authorization: 'Bearer abcde',
         'x-prismeai-api-key': 'fghij',
       },
       withCredentials: true,

package/lib/events.ts

@@ -20,46 +20,81 @@ export class Events {
   private listenedUserTopics: Map<string, string[]>;
   private listeners: Map<string, Function[]> = new Map();
   private lastReceivedEventDate: Date;
+  private socketId?: string;
 
   constructor({
     workspaceId,
     token,
+    legacyToken,
     apiKey,
     apiHost = 'https://api.eda.prisme.ai',
     filters,
     api,
+    transports,
   }: {
     workspaceId: string;
     token: string;
+    legacyToken?: string;
     apiKey?: string;
     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 = {
-      'x-prismeai-token': token,
-    };
+    const extraHeaders: any = 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],
@@ -72,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() {
@@ -101,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) {

package/lib/fetcher.ts

@@ -1,5 +1,7 @@
+import FormData from 'form-data';
 import ApiError from './ApiError';
 import HTTPError from './HTTPError';
+import { wait } from './utils';
 
 const headersAsObject = (headers: Headers) =>
   Array.from(headers).reduce(
@@ -10,36 +12,61 @@ const headersAsObject = (headers: Headers) =>
     {}
   );
 
+export type Fetched<T> = T & {
+  headers?: Record<string, any>;
+};
+
+function isFormData(data: any): data is FormData {
+  return !!(data.append && typeof data.append === 'function');
+}
+
+const CSRF_TOKEN_HEADER = 'x-prismeai-csrf-token';
+
 export class Fetcher {
   public host: string;
   public token: string | null = null;
+  public legacyToken: string | null = null;
+  public overwriteClientId?: string;
+  private clientIdHeader?: string;
   protected _apiKey: string | null = null;
+  protected _csrfToken: string | null = null;
   public language: string | undefined;
+  public lastReceivedHeaders?: Record<string, any>;
 
-  constructor(host: string) {
+  constructor(host: string, clientIdHeader?: string) {
     this.host = host;
+    this.clientIdHeader = clientIdHeader;
   }
 
   set apiKey(apiKey: string) {
     this._apiKey = apiKey;
   }
 
-  prepareRequest(url: string,
-    options: RequestInit = {}) {
+  prepareRequest(url: string, options: RequestInit = {}) {
     const headers = new Headers(options.headers || {});
 
-    if (this.token && !headers.has('x-prismeai-token')) {
-      headers.append('x-prismeai-token', this.token);
+    if (this.token && !headers.has('Authorization')) {
+      headers.append('Authorization', `Bearer ${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._csrfToken && options.method && options.method !== 'GET') {
+      headers.append(CSRF_TOKEN_HEADER, this._csrfToken);
+    }
+
     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')
@@ -47,9 +74,12 @@ export class Fetcher {
       headers.append('Content-Type', 'application/json');
     }
 
-    headers.append('Access-Control-Allow-Origin', '*');
-
-    return global.fetch(`${this.host}${url}`, {
+    const fullUrl =
+      url.startsWith('http://') || url.startsWith('https://')
+        ? url
+        : `${this.host}${url}`;
+    return global.fetch(fullUrl, {
+      credentials: headers.has('Authorization') ? 'omit' : 'include',
       ...options,
       headers,
     });
@@ -57,11 +87,42 @@ export class Fetcher {
 
   protected async _fetch<T>(
     url: string,
-    options: RequestInit = {}
+    options: RequestInit = {},
+    maxRetries: number = 3
   ): Promise<T> {
-    const res = await this.prepareRequest(url, options);
+    let res: Response;
+    try {
+      res = await this.prepareRequest(url, options);
+    } catch (e: any) {
+      if (maxRetries > 0 && e.message === 'Load failed') {
+        await wait(20);
+        return this._fetch(url, options, --maxRetries);
+      }
+      throw e;
+    }
+    if (options.redirect === 'manual' && res.status === 0) {
+      return { redirected: true } as T;
+    }
 
+    this.lastReceivedHeaders = headersAsObject(res.headers);
+    if (this.clientIdHeader && this.lastReceivedHeaders[this.clientIdHeader]) {
+      this.overwriteClientId = this.lastReceivedHeaders[this.clientIdHeader];
+    }
+    if (this.lastReceivedHeaders[CSRF_TOKEN_HEADER]) {
+      this._csrfToken = this.lastReceivedHeaders[CSRF_TOKEN_HEADER];
+    }
     if (!res.ok) {
+      if (
+        res.statusText?.length &&
+        res.statusText.includes('ECONNRESET') &&
+        maxRetries > 0
+      ) {
+        console.log(
+          `Retrying request towards ${url} as we received ECONNRESET error : ${res.statusText}`
+        );
+        await wait(20);
+        return this._fetch(url, options, --maxRetries);
+      }
       let error;
       try {
         error = new ApiError(await res.json(), res.status);
@@ -102,10 +163,14 @@ export class Fetcher {
     });
   }
 
-  async post<T>(url: string, body?: Record<string, any>) {
+  async post<T>(url: string, body?: Record<string, any>, opts?: RequestInit) {
     return this._fetch<T>(url, {
       method: 'POST',
-      body: body && !(body instanceof FormData) ? JSON.stringify(body) : body,
+      body:
+        body && !isFormData(body) && !(body instanceof URLSearchParams)
+          ? JSON.stringify(body)
+          : (body as BodyInit),
+      ...opts,
     });
   }
 

package/lib/utils.ts

@@ -10,3 +10,42 @@ export const removedUndefinedProperties = (
     }
     return newObject;
   }, {});
+
+export function dataURItoBlob(dataURI: string): [Blob, string] {
+  // convert base64/URLEncoded data component to raw binary data held in a string
+  let byteString;
+  if (dataURI.split(',')[0].indexOf('base64') >= 0)
+    byteString = atob(dataURI.split(',')[1].split(';')[0]);
+  else byteString = unescape(dataURI.split(',')[1]);
+  // separate out the mime component
+  const metadata = dataURI
+    .split(';')
+    .map((v) => v.split(/:/))
+    .filter((pair) => pair.length === 2);
+  const [, mimeString = ''] = metadata.find(([k, v]) => k === 'data') || [];
+  const [, ext] = mimeString.split(/\//);
+  const [, fileName = `file.${ext}`] =
+    metadata.find(([k, v]) => k === 'filename') || [];
+
+  const sanitizedFileName = encodeURIComponent(
+    decodeURIComponent(fileName).replace(/[;,\s]/g, '-')
+  );
+
+  // write the bytes of the string to a typed array
+  let ia = new Uint8Array(byteString.length);
+  for (var i = 0; i < byteString.length; i++) {
+    ia[i] = byteString.charCodeAt(i);
+  }
+
+  return [new Blob([ia], { type: mimeString }), sanitizedFileName];
+}
+
+export function isDataURL(file: any): file is string {
+  return !!(typeof file === 'string' && file.match(/^data\:/));
+}
+
+export async function wait(delay: number = 0) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisme.ai/sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Communicate with Prisme.ai API",
   "main": "dist/sdk/index.js",
   "scripts": {
@@ -10,6 +10,8 @@
   "license": "ISC",
   "dependencies": {
     "@prisme.ai/types": "^1.0.9",
+    "form-data": "^4.0.0",
+    "pkce-challenge": "^3.1.0",
     "qs": "^6.10.3",
     "socket.io-client": "^4.4.1"
   }