@prisme.ai/sdk 0.0.2

package/lib/api.ts

@@ -0,0 +1,439 @@
+import QueryString from 'qs';
+import Fetcher from './fetcher';
+import { Event, Workspace } from './types';
+import { Events } from './events';
+import { removedUndefinedProperties } from './utils';
+
+type UserPermissions = Prismeai.UserPermissions;
+
+interface PageWithMetadata extends Prismeai.Page {
+  createdAt: string;
+  createdBy: string;
+  updatedAt: string;
+  updatedBy: string;
+}
+
+export class Api extends Fetcher {
+  async me() {
+    return await this.get('/me');
+  }
+
+  async signin(
+    email: string,
+    password: string
+  ): Promise<
+    Prismeai.User & {
+      token: string;
+    }
+  > {
+    return await this.post('/login', {
+      email,
+      password,
+    });
+  }
+
+  async signup(
+    email: string,
+    password: string,
+    firstName: string,
+    lastName: string
+  ): Promise<
+    Prismeai.User & {
+      token: string;
+    }
+  > {
+    return await this.post('/signup', {
+      email: email,
+      password,
+      firstName,
+      lastName,
+    });
+  }
+
+  async signout() {
+    await this.post('/logout');
+    this.token = null;
+  }
+
+  // Workspaces
+  async getWorkspaces(): Promise<Workspace[]> {
+    return await this.get('/workspaces?limit=300');
+  }
+
+  async getWorkspace(id: string): Promise<Workspace | null> {
+    return await this.get(`/workspaces/${id}`);
+  }
+
+  async createWorkspace(name: string): Promise<Workspace> {
+    return await this.post('/workspaces', { name });
+  }
+
+  async updateWorkspace(workspace: Workspace): Promise<Workspace> {
+    return await this.patch(
+      `/workspaces/${workspace.id}`,
+      await this.replaceAllImagesData(workspace, workspace.id)
+    );
+  }
+
+  async deleteWorkspace(workspaceId: Workspace['id']): Promise<Workspace> {
+    return await this.delete(`/workspaces/${workspaceId}`);
+  }
+
+  // Automations
+  async createAutomation(
+    workspace: Workspace,
+    automation: Prismeai.Automation
+  ): Promise<Prismeai.Automation & { slug: string }> {
+    return await this.post(`/workspaces/${workspace.id}/automations`, {
+      ...automation,
+    });
+  }
+
+  async updateAutomation(
+    workspace: Workspace,
+    slug: string,
+    automation: Prismeai.Automation
+  ): Promise<Prismeai.Automation & { slug: string }> {
+    return await this.patch(
+      `/workspaces/${workspace.id}/automations/${slug}`,
+      await this.replaceAllImagesData(automation, workspace.id)
+    );
+  }
+
+  async deleteAutomation(workspace: Workspace, slug: string): Promise<string> {
+    return await this.delete(`/workspaces/${workspace.id}/automations/${slug}`);
+  }
+
+  // Pages
+  async getPages(
+    workspaceId: NonNullable<Workspace['id']>
+  ): Promise<Prismeai.Page[]> {
+    try {
+      const pages = await this.get<PageWithMetadata[]>(
+        `/workspaces/${workspaceId}/pages`
+      );
+      return pages.map(
+        ({ createdAt, createdBy, updatedAt, updatedBy, ...page }: any) => page
+      );
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async getPage(
+    workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId,
+    pageId: PrismeaiAPI.GetPage.Parameters.Id
+  ): Promise<Prismeai.DetailedPage> {
+    return await this.get(`/workspaces/${workspaceId}/pages/${pageId}`);
+  }
+
+  async getPageBySlug(
+    pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.Slug
+  ): Promise<Prismeai.DetailedPage> {
+    return await this.get(`/pages/${pageSlug}`);
+  }
+
+  async createPage(
+    workspaceId: NonNullable<Workspace['id']>,
+    page: Prismeai.Page
+  ): Promise<Prismeai.Page> {
+    const {
+      createdAt,
+      createdBy,
+      updatedAt,
+      updatedBy,
+      ...newPage
+    } = await this.post<PageWithMetadata>(
+      `/workspaces/${workspaceId}/pages`,
+      page
+    );
+    return newPage;
+  }
+
+  // Replace images as dataurl to uploaded url in any type of data
+
+  async updatePage(
+    workspaceId: NonNullable<Workspace['id']>,
+    page: Prismeai.Page
+  ): Promise<Prismeai.Page> {
+    const {
+      createdAt,
+      createdBy,
+      updatedAt,
+      updatedBy,
+      ...updatedPage
+    } = await this.patch<PageWithMetadata>(
+      `/workspaces/${workspaceId}/pages/${page.id}`,
+      await this.replaceAllImagesData(page, workspaceId)
+    );
+    return updatedPage;
+  }
+
+  async deletePage(
+    workspaceId: NonNullable<Workspace['id']>,
+    pageId: string
+  ): Promise<Pick<Prismeai.Page, 'id'>> {
+    return await this.delete(`/workspaces/${workspaceId}/pages/${pageId}`);
+  }
+
+  // Events
+  streamEvents(workspaceId: string): Promise<Events> {
+    const events = new Events(workspaceId, this.token || '', this.host);
+    return new Promise((resolve, reject) => {
+      events.once('connect', () => {
+        resolve(events);
+      });
+      events.once('connect_error', () => {
+        reject();
+        events.close();
+      });
+    });
+  }
+
+  async getEvents(
+    workspaceId: string,
+    options: { beforeDate?: Date | string } = {}
+  ): Promise<Event<Date>[]> {
+    try {
+      const query = QueryString.stringify(options);
+      const {
+        result: { events },
+      } = await this.get<{
+        result: {
+          events: Event<string>[];
+        };
+      }>(`/workspaces/${workspaceId}/events${query && `?${query}`}`);
+      return events.map(({ createdAt, ...event }) => ({
+        ...event,
+        createdAt: new Date(createdAt),
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async postEvents(
+    workspaceId: PrismeaiAPI.SendWorkspaceEvent.Parameters.WorkspaceId,
+    events: PrismeaiAPI.SendWorkspaceEvent.RequestBody['events']
+  ): Promise<boolean> {
+    try {
+      await this.post<PrismeaiAPI.SendWorkspaceEvent.Responses.$200>(
+        `/workspaces/${workspaceId}/events`,
+        {
+          events,
+        }
+      );
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  async getPermissions(
+    subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType,
+    subjectId: string
+  ): Promise<PrismeaiAPI.GetPermissions.Responses.$200> {
+    return await this.get(`/${subjectType}/${subjectId}/permissions`);
+  }
+
+  async addPermissions(
+    subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType,
+    subjectId: string,
+    permissions: UserPermissions
+  ): Promise<PrismeaiAPI.Share.Responses.$200> {
+    return await this.post(
+      `/${subjectType}/${subjectId}/permissions`,
+      permissions
+    );
+  }
+
+  async deletePermissions(
+    subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType,
+    subjectId: string,
+    userEmail: string
+  ): Promise<PrismeaiAPI.RevokePermissions.Responses.$200> {
+    return await this.delete(
+      `/${subjectType}/${subjectId}/permissions/${userEmail}`
+    );
+  }
+
+  async getApps({
+    query,
+    page,
+    limit,
+    workspaceId,
+  }: {
+    query?: PrismeaiAPI.SearchApps.QueryParameters['text'];
+    page?: PrismeaiAPI.SearchApps.QueryParameters['page'];
+    limit?: PrismeaiAPI.SearchApps.QueryParameters['limit'];
+    workspaceId?: PrismeaiAPI.SearchApps.QueryParameters['workspaceId'];
+  }): Promise<PrismeaiAPI.SearchApps.Responses.$200> {
+    const params = new URLSearchParams(
+      removedUndefinedProperties(
+        {
+          text: `${query || ''}`,
+          page: `${page || ''}`,
+          limit: `${limit || ''}`,
+          workspaceId: `${workspaceId || ''}`,
+        },
+        true
+      )
+    );
+    return await this.get(`/apps?${params.toString()}`);
+  }
+
+  async installApp(
+    workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'],
+    body: PrismeaiAPI.InstallAppInstance.RequestBody
+  ): Promise<PrismeaiAPI.InstallAppInstance.Responses.$200> {
+    return await this.post(`/workspaces/${workspaceId}/apps`, body);
+  }
+
+  async updateApp(
+    workspaceId: PrismeaiAPI.ConfigureAppInstance.PathParameters['workspaceId'],
+    slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug'],
+    body: PrismeaiAPI.ConfigureAppInstance.RequestBody
+  ): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200> {
+    return await this.patch(`/workspaces/${workspaceId}/apps/${slug}`, body);
+  }
+
+  async uninstallApp(
+    workspaceId: PrismeaiAPI.UninstallAppInstance.PathParameters['workspaceId'],
+    slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug']
+  ): Promise<PrismeaiAPI.UninstallAppInstance.Responses.$200> {
+    return await this.delete(`/workspaces/${workspaceId}/apps/${slug}`);
+  }
+
+  async publishApp(
+    body: PrismeaiAPI.PublishApp.RequestBody
+  ): Promise<PrismeaiAPI.PublishApp.Responses.$200> {
+    return await this.post(`/apps`, body);
+  }
+
+  async listAppInstances(
+    workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']
+  ): Promise<PrismeaiAPI.ListAppInstances.Responses.$200> {
+    return await this.get(`/workspaces/${workspaceId}/apps`);
+  }
+
+  async fetchImports(
+    workspaceId: PrismeaiAPI.ListAppInstances.Parameters.WorkspaceId
+  ): Promise<PrismeaiAPI.ListAppInstances.Responses.$200> {
+    return await this.get(`/workspaces/${workspaceId}/apps`);
+  }
+
+  async getAppConfig<T>(
+    workspaceId: PrismeaiAPI.GetAppInstanceConfig.Parameters.WorkspaceId,
+    slug: PrismeaiAPI.GetAppInstanceConfig.Parameters.Slug
+  ): Promise<T> {
+    const config = await this.get<T>(
+      `/workspaces/${workspaceId}/apps/${slug}/config`
+    );
+    return config as T;
+  }
+
+  async updateAppConfig(
+    workspaceId: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.WorkspaceId,
+    slug: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.Slug,
+    config: any
+  ): Promise<PrismeaiAPI.UpdateAppInstanceConfig.Responses.$200['config']> {
+    await this.patch<Prismeai.AppInstance>(
+      `/workspaces/${workspaceId}/apps/${slug}/config`,
+      { ...config }
+    );
+    return config;
+  }
+
+  async uploadFiles(files: string | string[], workspaceId: string) {
+    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]);
+      else byteString = unescape(dataURI.split(',')[1]);
+
+      // separate out the mime component
+      const metadata = dataURI
+        .split(';')
+        .filter((v, k, all) => k < all.length - 1)
+        .map((v) => v.split(/:/));
+      const [, mimeString = ''] = metadata.find(([k, v]) => k === 'data') || [];
+      const [, ext] = mimeString.split(/\//);
+      const [, fileName = `file.${ext}`] =
+        metadata.find(([k, v]) => k === 'filename') || [];
+
+      // 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 }), fileName];
+    }
+    const formData = new FormData();
+    (Array.isArray(files) ? files : [files]).forEach((file) => {
+      formData.append('file', ...dataURItoBlob(file));
+    });
+
+    try {
+      return await this._fetch<PrismeaiAPI.UploadFile.Responses.$200>(
+        `/workspaces/${workspaceId}/files`,
+        {
+          method: 'POST',
+          body: formData,
+        }
+      );
+    } catch (e) {}
+    return [];
+  }
+
+  async replaceAllImagesData(original: any, workspaceId: string) {
+    const key = '…uploading-';
+    const toUpload: string[] = [];
+    const searchImages = (mayHaveImage: any, uploaded?: string[]) => {
+      switch (typeof mayHaveImage) {
+        case 'string':
+          if (uploaded && mayHaveImage.match(key)) {
+            // Replace with url
+            const [, index] = mayHaveImage.split(key);
+            return uploaded[+index];
+          }
+          if (mayHaveImage.match(/^data:/)) {
+            toUpload.push(mayHaveImage);
+            return `${key}${toUpload.length - 1}`;
+          }
+          return mayHaveImage;
+        case 'object':
+          const isArray = Array.isArray(mayHaveImage);
+          const withImagesUrl = isArray
+            ? [...mayHaveImage]
+            : { ...mayHaveImage };
+          for (const key of Object.keys(withImagesUrl)) {
+            withImagesUrl[key] = searchImages(withImagesUrl[key], uploaded);
+          }
+          return withImagesUrl;
+        default:
+          return mayHaveImage;
+      }
+    };
+
+    const searching = searchImages(original);
+
+    if (toUpload.length === 0) return original;
+
+    const uploaded = await this.uploadFiles(toUpload, workspaceId);
+
+    const replaced = searchImages(
+      searching,
+      uploaded.map(({ url }) => url)
+    );
+
+    return replaced;
+  }
+
+  async callAutomation(workspaceId: string, automation: string): Promise<any> {
+    return this._fetch(`/workspaces/${workspaceId}/webhooks/${automation}`);
+  }
+}
+
+export default new Api('https://api.eda.prisme.ai');

package/lib/events.test.ts

@@ -0,0 +1,57 @@
+import getConfig from 'next/config';
+import Events from './events';
+import io from 'socket.io-client';
+
+const { publicRuntimeConfig } = getConfig();
+
+jest.mock('socket.io-client', () => {
+  const mock = {
+    disconnect: jest.fn(),
+    onAny: jest.fn(),
+    offAny: jest.fn(),
+    once: jest.fn(),
+  };
+  const io = jest.fn(() => mock);
+  return io;
+});
+
+it('should connect to Websocket', () => {
+  const client = new Events('1', 'abcde');
+  expect(io).toHaveBeenCalledWith(
+    `https://api.eda.prisme.ai/workspaces/1/events`,
+    {
+      extraHeaders: {
+        'x-prismeai-session-token': 'abcde',
+      },
+    }
+  );
+});
+
+it('should disconnect to Websocket', () => {
+  const client = new Events('1', 'abcde');
+  (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 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('1', 'abcde');
+  const listener = () => null;
+  const off = client.all(listener);
+  expect(io().onAny).toHaveBeenCalledWith(listener);
+  off();
+  expect(io().offAny).toHaveBeenCalledWith(listener);
+});

package/lib/events.ts

@@ -0,0 +1,69 @@
+import io, { Socket } from 'socket.io-client';
+
+export class Events {
+  protected client: Socket;
+  public workspaceId: string;
+
+  constructor(
+    workspaceId: string,
+    token: string,
+    apiHost: string = 'https://api.eda.prisme.ai'
+  ) {
+    this.workspaceId = workspaceId;
+    this.client = io(`${apiHost}/workspaces/${workspaceId}/events`, {
+      extraHeaders: {
+        'x-prismeai-session-token': token,
+      },
+    });
+  }
+
+  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(listener);
+
+    return () => this.client.offAny(listener);
+  }
+
+  on(
+    ev: string,
+    listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void
+  ) {
+    this.client.on(ev, listener);
+    return () => this.client.off(ev, listener);
+  }
+
+  emit(event: string, payload?: any) {
+    this.client.emit('event', {
+      type: event,
+      payload,
+    });
+  }
+
+  once(
+    ev: string,
+    listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void
+  ) {
+    this.client.once(ev, listener);
+  }
+
+  close() {
+    this.client.close();
+  }
+}
+
+export default Events;