@prisme.ai/sdk 0.0.2 → 1.0.0

package/lib/events.test.ts

@@ -1,14 +1,14 @@
 import getConfig from 'next/config';
 import Events from './events';
 import io from 'socket.io-client';
-
-const { publicRuntimeConfig } = getConfig();
+import { Api } from './api';
 
 jest.mock('socket.io-client', () => {
   const mock = {
     disconnect: jest.fn(),
     onAny: jest.fn(),
     offAny: jest.fn(),
+    on: jest.fn(),
     once: jest.fn(),
   };
   const io = jest.fn(() => mock);
@@ -16,26 +16,54 @@ jest.mock('socket.io-client', () => {
 });
 
 it('should connect to Websocket', () => {
-  const client = new Events('1', 'abcde');
+  new Events({ workspaceId: '1', token: 'abcde', api: {} as Api });
+  expect(io).toHaveBeenCalledWith(
+    `https://api.eda.prisme.ai/workspaces/1/events`,
+    {
+      extraHeaders: {
+        'x-prismeai-token': 'abcde',
+      },
+      withCredentials: true,
+    }
+  );
+});
+
+it('should connect to Websocket with apiKey', () => {
+  new Events({
+    workspaceId: '1',
+    token: 'abcde',
+    apiKey: 'fghij',
+    api: {} as Api,
+  });
   expect(io).toHaveBeenCalledWith(
     `https://api.eda.prisme.ai/workspaces/1/events`,
     {
       extraHeaders: {
-        'x-prismeai-session-token': 'abcde',
+        'x-prismeai-token': 'abcde',
+        'x-prismeai-api-key': 'fghij',
       },
+      withCredentials: true,
     }
   );
 });
 
 it('should disconnect to Websocket', () => {
-  const client = new Events('1', 'abcde');
+  const client = new Events({
+    workspaceId: '1',
+    token: 'abcde',
+    api: {} as Api,
+  });
   (client as any).client.connected = true;
   client.destroy();
   expect(io().disconnect).toHaveBeenCalled();
 });
 
 it('should wait before disconnecting Websocket', () => {
-  const client = new Events('1', 'abcde');
+  const client = new Events({
+    workspaceId: '1',
+    token: 'abcde',
+    api: {} as Api,
+  });
   const ioInstance = io();
   (client as any).client.connected = false;
   ((client as any).client.once as jest.Mock).mockClear();
@@ -48,7 +76,11 @@ it('should wait before disconnecting Websocket', () => {
 });
 
 it('should listen to all events', () => {
-  const client = new Events('1', 'abcde');
+  const client = new Events({
+    workspaceId: '1',
+    token: 'abcde',
+    api: {} as Api,
+  });
   const listener = () => null;
   const off = client.all(listener);
   expect(io().onAny).toHaveBeenCalledWith(listener);

package/lib/events.ts

@@ -1,20 +1,87 @@
 import io, { Socket } from 'socket.io-client';
 
+import { Api } from './api';
+
+export type PayloadQuery = Record<string, string | string[]>;
+export type OrQuery = PayloadQuery[];
+
+export type SearchOptions = Omit<
+  PrismeaiAPI.EventsLongpolling.QueryParameters,
+  'query' | 'types'
+> & {
+  payloadQuery?: PayloadQuery | OrQuery;
+  types?: string[];
+};
+
 export class Events {
   protected client: Socket;
   public workspaceId: string;
+  private filters: Record<string, any>[];
+  private listenedUserTopics: Map<string, string[]>;
+  private listeners: Map<string, Function[]> = new Map();
+  private lastReceivedEventDate: Date;
 
-  constructor(
-    workspaceId: string,
-    token: string,
-    apiHost: string = 'https://api.eda.prisme.ai'
-  ) {
+  constructor({
+    workspaceId,
+    token,
+    apiKey,
+    apiHost = 'https://api.eda.prisme.ai',
+    filters,
+    api,
+  }: {
+    workspaceId: string;
+    token: string;
+    apiKey?: string;
+    apiHost?: string;
+    filters?: Record<string, any>;
+    api: Api;
+  }) {
     this.workspaceId = workspaceId;
-    this.client = io(`${apiHost}/workspaces/${workspaceId}/events`, {
-      extraHeaders: {
-        'x-prismeai-session-token': token,
-      },
+    const queryString = new URLSearchParams(filters || {}).toString();
+    const fullQueryString = queryString ? `?${queryString}` : '';
+    const extraHeaders: any = {
+      'x-prismeai-token': token,
+    };
+    this.lastReceivedEventDate = new Date();
+    if (apiKey) {
+      extraHeaders['x-prismeai-api-key'] = apiKey;
+    }
+
+    this.client = io(
+      `${apiHost}/workspaces/${workspaceId}/events${fullQueryString}`,
+      {
+        extraHeaders,
+        withCredentials: true,
+      }
+    );
+
+    const onConnect = () => {
+      // Reset last filters
+      this.updateFilters({
+        payloadQuery: this.filters,
+      });
+      setTimeout(async () => {
+        const events = await api.getEvents(workspaceId, {
+          ...this.filters[this.filters.length - 1],
+          afterDate: this.lastReceivedEventDate.toISOString(),
+        });
+        events.reverse().forEach((event) => {
+          (this.listeners.get(event.type) || []).forEach((listener) =>
+            listener(event)
+          );
+        });
+      }, 2000);
+    };
+    this.client.on('disconnect', () => {
+      if (!this.lastReceivedEventDate) {
+        this.lastReceivedEventDate = new Date();
+      }
+      this.client.off('connect', onConnect);
+      this.client.on('connect', onConnect);
     });
+
+    this.filters = [filters || {}];
+    this.listenedUserTopics = new Map();
   }
 
   get socket() {
@@ -34,31 +101,71 @@ export class Events {
   }
 
   all(listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void) {
-    this.client.onAny(listener);
+    this.client.onAny((eventName: string, eventData: Prismeai.PrismeEvent) => {
+      this.lastReceivedEventDate = new Date(eventData?.createdAt);
+      return listener(eventName, eventData);
+    });
 
     return () => this.client.offAny(listener);
   }
 
-  on(
-    ev: string,
-    listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void
-  ) {
+  on(ev: string, listener: (eventData: Prismeai.PrismeEvent) => void) {
+    this.listeners.set(ev, [...(this.listeners.get(ev) || []), listener]);
+
     this.client.on(ev, listener);
-    return () => this.client.off(ev, listener);
+    return () => {
+      this.listeners.set(
+        ev,
+        (this.listeners.get(ev) || []).filter((l) => l !== listener)
+      );
+      this.client.off(ev, listener);
+    };
   }
 
-  emit(event: string, payload?: any) {
+  emit(event: string, payload?: any, options?: any) {
     this.client.emit('event', {
       type: event,
       payload,
+      options,
     });
   }
 
+  listenTopics({
+    event,
+    topics,
+  }: {
+    event: string;
+    topics: string | string[];
+  }) {
+    topics = Array.isArray(topics) ? topics : [topics];
+
+    this.listenedUserTopics.set(event, topics);
+
+    this.filters = [
+      { ...this.filters[0] },
+      {
+        'target.userTopic': Array.from(this.listenedUserTopics).flatMap(
+          ([_event, topics]) => topics
+        ),
+      },
+    ];
+    this.updateFilters({
+      payloadQuery: this.filters,
+    });
+  }
+
+  updateFilters(filters: SearchOptions) {
+    this.client.emit('filters', filters);
+  }
+
   once(
     ev: string,
     listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void
   ) {
     this.client.once(ev, listener);
+    return () => {
+      this.client.off(ev, listener);
+    };
   }
 
   close() {

package/lib/fetcher.test.ts

@@ -7,16 +7,15 @@ it('should fetch', async () => {
   // @ts-ignore
   global.fetch = jest.fn(() => ({
     ok: true,
-    headers: [['foo', 'bar']],
-    json() {
-      return undefined;
+    headers: new Headers([['foo', 'bar']]),
+    text() {
+      return '';
     },
     clone() {
       return { ...this };
     },
   }));
   const o = await fetcher.get('url');
-  expect(o.headers).toEqual({ foo: 'bar' });
   expect(global.fetch).toHaveBeenCalledWith('http/url', {
     headers: expect.any(Headers),
     method: 'GET',
@@ -31,9 +30,9 @@ it('should fetch with auth', async () => {
   // @ts-ignore
   global.fetch = jest.fn(() => ({
     ok: true,
-    headers: {},
-    json() {
-      return {};
+    headers: new Headers(),
+    text() {
+      return '';
     },
     clone() {
       return { ...this };
@@ -47,7 +46,33 @@ it('should fetch with auth', async () => {
   });
   const headers = (global.fetch as jest.Mock).mock.calls[0][1].headers;
   expect(headers.get('Access-Control-Allow-Origin')).toBe('*');
-  expect(headers.get('x-prismeai-session-token')).toBe('token');
+  expect(headers.get('x-prismeai-token')).toBe('token');
+});
+
+it('should fetch with api key', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: new Headers(),
+    text() {
+      return '';
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  fetcher.token = 'token';
+  fetcher.apiKey = 'api-key';
+  await fetcher.get('url');
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'GET',
+  });
+  const headers = (global.fetch as jest.Mock).mock.calls[0][1].headers;
+  expect(headers.get('Access-Control-Allow-Origin')).toBe('*');
+  expect(headers.get('x-prismeai-token')).toBe('token');
+  expect(headers.get('x-prismeai-api-key')).toBe('api-key');
 });
 
 it('should fail to fetch', async () => {
@@ -103,7 +128,7 @@ it('should post', async () => {
   // @ts-ignore
   global.fetch = jest.fn(() => ({
     ok: true,
-    headers: {},
+    headers: new Headers([['content-type', 'application/json']]),
     json() {
       return {};
     },
@@ -123,7 +148,7 @@ it('should post with body', async () => {
   // @ts-ignore
   global.fetch = jest.fn(() => ({
     ok: true,
-    headers: {},
+    headers: new Headers([['content-type', 'application/json']]),
     json() {
       return {};
     },
@@ -139,12 +164,33 @@ it('should post with body', async () => {
   });
 });
 
+it('should put', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: new Headers([['content-type', 'application/json']]),
+    json() {
+      return {};
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  await fetcher.put('url', {});
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'PUT',
+    body: '{}',
+  });
+});
+
 it('should patch', async () => {
   const fetcher = new Fetcher('http/');
   // @ts-ignore
   global.fetch = jest.fn(() => ({
     ok: true,
-    headers: {},
+    headers: new Headers([['content-type', 'application/json']]),
     json() {
       return {};
     },
@@ -165,7 +211,7 @@ it('should delete', async () => {
   // @ts-ignore
   global.fetch = jest.fn(() => ({
     ok: true,
-    headers: {},
+    headers: new Headers([['content-type', 'application/json']]),
     json() {
       return {};
     },
@@ -185,7 +231,7 @@ it('should use formData', async () => {
   // @ts-ignore
   global.fetch = jest.fn(() => ({
     ok: true,
-    headers: {},
+    headers: new Headers([['content-type', 'application/json']]),
     json() {
       return {};
     },

package/lib/fetcher.ts

@@ -13,19 +13,31 @@ const headersAsObject = (headers: Headers) =>
 export class Fetcher {
   public host: string;
   public token: string | null = null;
+  protected _apiKey: string | null = null;
+  public language: string | undefined;
 
   constructor(host: string) {
     this.host = host;
   }
 
-  protected async _fetch<T>(
-    url: string,
-    options: RequestInit = {}
-  ): Promise<T> {
+  set apiKey(apiKey: string) {
+    this._apiKey = apiKey;
+  }
+
+  prepareRequest(url: string,
+    options: RequestInit = {}) {
     const headers = new Headers(options.headers || {});
 
-    if (this.token && !headers.has('x-prismeai-session-token')) {
-      headers.append('x-prismeai-session-token', this.token);
+    if (this.token && !headers.has('x-prismeai-token')) {
+      headers.append('x-prismeai-token', this.token);
+    }
+
+    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 (
@@ -37,10 +49,17 @@ export class Fetcher {
 
     headers.append('Access-Control-Allow-Origin', '*');
 
-    const res = await global.fetch(`${this.host}${url}`, {
+    return global.fetch(`${this.host}${url}`, {
       ...options,
       headers,
     });
+  }
+
+  protected async _fetch<T>(
+    url: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const res = await this.prepareRequest(url, options);
 
     if (!res.ok) {
       let error;
@@ -52,18 +71,28 @@ export class Fetcher {
       throw error;
     }
 
-    const clone = res.clone();
+    const contentType = res.headers.get('content-type');
+    if (contentType && contentType.includes('application/json')) {
+      try {
+        const response = (await res.json()) || {};
+        Object.defineProperty(response, 'headers', {
+          value: headersAsObject(res.headers),
+          configurable: false,
+          enumerable: false,
+          writable: false,
+        });
+        return response as T;
+      } catch (e) {
+        return {} as T;
+      }
+    }
+
+    const text = await res.text();
+
     try {
-      const response = (await res.json()) || {};
-      Object.defineProperty(response, 'headers', {
-        value: headersAsObject(res.headers),
-        configurable: false,
-        enumerable: false,
-        writable: false,
-      });
-      return response;
-    } catch (e) {
-      return ((await clone.text()) as unknown) as T;
+      return JSON.parse(text) as T;
+    } catch {
+      return text as T;
     }
   }
 
@@ -80,6 +109,13 @@ export class Fetcher {
     });
   }
 
+  async put<T>(url: string, body: Record<string, any>) {
+    return this._fetch<T>(url, {
+      method: 'PUT',
+      body: JSON.stringify(body),
+    });
+  }
+
   async patch<T>(url: string, body: Record<string, any>) {
     return this._fetch<T>(url, {
       method: 'PATCH',

package/lib/types.ts

@@ -2,6 +2,10 @@ import '@prisme.ai/types';
 
 export interface Workspace extends Prismeai.Workspace {
   id: string;
+  updatedAt: Date;
+  updatedBy: string;
+  createdAt: Date;
+  createdBy: string;
 }
 
 export interface Event<DateType extends Date | string>
@@ -9,7 +13,7 @@ export interface Event<DateType extends Date | string>
   createdAt: DateType;
 }
 
-export type EventsFilters = {
+export type EventsFilters = Record<string, string> & {
   afterDate?: PrismeaiAPI.EventsLongpolling.Parameters.AfterDate;
   beforeDate?: PrismeaiAPI.EventsLongpolling.Parameters.BeforeDate;
   text?: PrismeaiAPI.EventsLongpolling.Parameters.Text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisme.ai/sdk",
-  "version": "0.0.2",
+  "version": "1.0.0",
   "description": "Communicate with Prisme.ai API",
   "main": "dist/sdk/index.js",
   "scripts": {