@prisme.ai/sdk 1.0.2 → 2.0.1

package/lib/endpoints/users.ts

@@ -1,58 +0,0 @@
-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,121 +0,0 @@
-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 {
-  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);
-  }
-
-  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

@@ -1,38 +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) {
-    return this.api.post(`/workspaces/${this.workspaceId}/versions`, version);
-  }
-  rollback(
-    versionId: PrismeaiAPI.PullWorkspaceVersion.PathParameters['versionId'],
-    opts?: PrismeaiAPI.PullWorkspaceVersion.RequestBody
-  ) {
-    return this.api.post(
-      `/workspaces/${this.workspaceId}/versions/${versionId}/pull`,
-      opts
-    );
-  }
-
-  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,222 +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;
-  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 = 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: !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 = () => {
-      // 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],
-          afterDate: this.lastReceivedEventDate.toISOString(),
-        });
-        events.reverse().forEach((event) => {
-          (this.listeners.get(event.type) || []).forEach((listener) =>
-            listener(event)
-          );
-        });
-      }, 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);
-    });
-  }
-
-  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) {
-    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(anyListener);
-  }
-
-  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;