@prisme.ai/sdk 1.0.1 → 2.0.1

package/lib/endpoints/users.ts

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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,89 +0,0 @@
-import getConfig from 'next/config';
-import Events from './events';
-import io from 'socket.io-client';
-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);
-  return io;
-});
-
-it('should connect to Websocket', () => {
-  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: {
-        Authorization: 'Bearer abcde',
-        'x-prismeai-api-key': 'fghij',
-      },
-      withCredentials: true,
-    }
-  );
-});
-
-it('should disconnect to Websocket', () => {
-  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({
-    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();
-  ioInstance.disconnect = jest.fn();
-  client.destroy();
-  expect(ioInstance.disconnect).not.toHaveBeenCalled();
-  expect((client as any).client.once).toHaveBeenCalled();
-  ((client as any).client.once as jest.Mock).mock.calls[0][1]();
-  expect(ioInstance.disconnect).toHaveBeenCalled();
-});
-
-it('should listen to all events', () => {
-  const client = new Events({
-    workspaceId: '1',
-    token: 'abcde',
-    api: {} as Api,
-  });
-  const listener = () => null;
-  const off = client.all(listener);
-  expect(io().onAny).toHaveBeenCalledWith(listener);
-  off();
-  expect(io().offAny).toHaveBeenCalledWith(listener);
-});

package/lib/events.ts

@@ -1,180 +0,0 @@
-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,
-    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;
-    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() {
-    return this.client;
-  }
-
-  destroy() {
-    this.workspaceId = '';
-
-    if (this.client.connected) {
-      this.client.disconnect();
-      return;
-    }
-    this.client.once('connect', () => {
-      this.client.disconnect();
-    });
-  }
-
-  all(listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void) {
-    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: (eventData: Prismeai.PrismeEvent) => void) {
-    this.listeners.set(ev, [...(this.listeners.get(ev) || []), listener]);
-
-    this.client.on(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, 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() {
-    this.client.close();
-  }
-}
-
-export default Events;

package/lib/fetcher.test.ts

@@ -1,246 +0,0 @@
-import ApiError from './ApiError';
-import Fetcher from './fetcher';
-import HTTPError from './HTTPError';
-
-it('should fetch', async () => {
-  const fetcher = new Fetcher('http/');
-  // @ts-ignore
-  global.fetch = jest.fn(() => ({
-    ok: true,
-    headers: new Headers([['foo', 'bar']]),
-    text() {
-      return '';
-    },
-    clone() {
-      return { ...this };
-    },
-  }));
-  const o = 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('Content-Type')).toBe('application/json');
-});
-
-it('should fetch with auth', 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';
-  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');
-});
-
-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 () => {
-  const fetcher = new Fetcher('http/');
-  // @ts-ignore
-  global.fetch = jest.fn(() => ({
-    ok: false,
-    json: () => ({
-      error: 'error',
-      message: 'message',
-    }),
-    status: 400,
-  }));
-  try {
-    await fetcher.get('url');
-  } catch (e) {
-    expect(e).toBeInstanceOf(ApiError);
-    if (e instanceof ApiError) {
-      expect(e.error).toBe('error');
-      expect(e.message).toBe('message');
-    }
-  }
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'GET',
-  });
-});
-
-it('should fail to fetch with unformatted error', async () => {
-  const fetcher = new Fetcher('http/');
-  // @ts-ignore
-  global.fetch = jest.fn(() => ({
-    ok: false,
-    statusText: 'error',
-    status: 400,
-  }));
-  try {
-    await fetcher.get('url');
-  } catch (e) {
-    expect(e).toBeInstanceOf(HTTPError);
-    if (e instanceof ApiError) {
-      expect(e.message).toBe('error');
-    }
-  }
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'GET',
-  });
-});
-
-it('should post', 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.post('url');
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'POST',
-  });
-});
-
-it('should post with body', 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.post('url', {});
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'POST',
-    body: '{}',
-  });
-});
-
-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: new Headers([['content-type', 'application/json']]),
-    json() {
-      return {};
-    },
-    clone() {
-      return { ...this };
-    },
-  }));
-  await fetcher.patch('url', {});
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'PATCH',
-    body: '{}',
-  });
-});
-
-it('should delete', 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.delete('url');
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'DELETE',
-  });
-});
-
-it('should use formData', 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 };
-    },
-  }));
-  const formData = new FormData();
-  await fetcher.post('url', formData);
-  const headers = (global.fetch as jest.Mock).mock.calls[0][1].headers;
-  expect(headers.has('Content-Type')).toBe(false);
-});