@prisme.ai/sdk 0.0.2 → 1.0.1

package/lib/endpoints/users.ts

@@ -0,0 +1,22 @@
+import { Api } from '../api';
+
+export class UsersEndpoint {
+  private id: string;
+  private api: Api;
+
+  constructor(id: string, api: Api) {
+    this.id = id;
+    this.api = api;
+  }
+
+  async setMeta(k: string, v: any) {
+    await this.api.post(`/user/meta`, {
+      [k]: v,
+    });
+  }
+  async deleteMeta(k: string) {
+    await this.api.delete(`/user/meta/${k}`);
+  }
+}
+
+export default UsersEndpoint;

package/lib/endpoints/workspaces.ts

@@ -0,0 +1,18 @@
+import { Api } from '../api';
+import WorkspacesVersionsEndpoint from './workspacesVersions';
+
+export class WorkspacesEndpoint {
+  private id: string;
+  private api: Api;
+
+  constructor(id: string, api: Api) {
+    this.id = id;
+    this.api = api;
+  }
+
+  get versions() {
+    return new WorkspacesVersionsEndpoint(this.id, this.api);
+  }
+}
+
+export default WorkspacesEndpoint;

package/lib/endpoints/workspacesVersions.ts

@@ -0,0 +1,34 @@
+import { Api } from '../api';
+
+export class WorkspacesVersionsEndpoint {
+  private workspaceId: string;
+  private api: Api;
+
+  constructor(workspaceId: string, api: Api) {
+    this.workspaceId = workspaceId;
+    this.api = api;
+  }
+
+  create(version?: PrismeaiAPI.PublishWorkspaceVersion.RequestBody) {
+    this.api.post(`/workspaces/${this.workspaceId}/versions`, version);
+  }
+  rollback(
+    versionId: PrismeaiAPI.RollbackWorkspaceVersion.PathParameters['versionId']
+  ) {
+    this.api.post(
+      `/workspaces/${this.workspaceId}/versions/${versionId}/rollback`
+    );
+  }
+
+  async export(version: PrismeaiAPI.ExportWorkspaceVersion.Parameters.VersionId = 'current') {
+    const res = await this.api.prepareRequest(
+      `/workspaces/${this.workspaceId}/versions/${version}/export`, {
+        method: 'post'
+      }
+    )
+    return new Blob([await res.arrayBuffer()], { type: 'application/zip' });
+    
+  }
+}
+
+export default WorkspacesVersionsEndpoint;

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: {
+        Authorization: 'Bearer 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',
+        Authorization: 'Bearer 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,91 @@
 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,
+    legacyToken,
+    apiKey,
+    apiHost = 'https://api.eda.prisme.ai',
+    filters,
+    api,
+  }: {
+    workspaceId: string;
+    token: string;
+    legacyToken?: 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 = token
+      ? {
+          Authorization: `Bearer ${token}`,
+        }
+      : { 'x-prismeai-token': legacyToken };
+    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 +105,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

@@ -10,22 +10,48 @@ const headersAsObject = (headers: Headers) =>
     {}
   );
 
+export type Fetched<T> = T & {
+  headers?: Record<string, any>;
+};
+
 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;
+  public language: string | undefined;
+  public lastReceivedHeaders?: Record<string, any>;
 
-  constructor(host: string) {
+  constructor(host: string, clientIdHeader?: string) {
     this.host = host;
+    this.clientIdHeader = clientIdHeader;
   }
 
-  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('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.language) {
+      headers.append('accept-language', this.language);
+    }
+
+    if (options.body instanceof URLSearchParams) {
+      headers.set('Content-Type', 'application/x-www-form-urlencoded');
     }
 
     if (
@@ -35,13 +61,30 @@ export class Fetcher {
       headers.append('Content-Type', 'application/json');
     }
 
-    headers.append('Access-Control-Allow-Origin', '*');
-
-    const res = await global.fetch(`${this.host}${url}`, {
+    const fullUrl =
+      url.startsWith('http://') || url.startsWith('https://')
+        ? url
+        : `${this.host}${url}`;
+    return global.fetch(fullUrl, {
+      credentials: 'include',
       ...options,
       headers,
     });
+  }
 
+  protected async _fetch<T>(
+    url: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const res = await this.prepareRequest(url, options);
+    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 (!res.ok) {
       let error;
       try {
@@ -52,18 +95,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;
     }
   }
 
@@ -73,10 +126,23 @@ 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 &&
+        !(body instanceof FormData) &&
+        !(body instanceof URLSearchParams)
+          ? JSON.stringify(body)
+          : body,
+      ...opts,
+    });
+  }
+
+  async put<T>(url: string, body: Record<string, any>) {
+    return this._fetch<T>(url, {
+      method: 'PUT',
+      body: JSON.stringify(body),
     });
   }
 

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.1",
   "description": "Communicate with Prisme.ai API",
   "main": "dist/sdk/index.js",
   "scripts": {
@@ -10,6 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "@prisme.ai/types": "^1.0.9",
+    "pkce-challenge": "^3.1.0",
     "qs": "^6.10.3",
     "socket.io-client": "^4.4.1"
   }