@prisme.ai/sdk 0.0.2 → 1.0.0

package/lib/api.ts

@@ -3,8 +3,8 @@ import Fetcher from './fetcher';
 import { Event, Workspace } from './types';
 import { Events } from './events';
 import { removedUndefinedProperties } from './utils';
-
-type UserPermissions = Prismeai.UserPermissions;
+import WorkspacesEndpoint from './endpoints/workspaces';
+import ApiError from './ApiError';
 
 interface PageWithMetadata extends Prismeai.Page {
   createdAt: string;
@@ -13,9 +13,30 @@ interface PageWithMetadata extends Prismeai.Page {
   updatedBy: string;
 }
 
+export type UserPermissions = {
+  permissions: Prismeai.UserPermissions['permissions'];
+  target: {
+    id?: string;
+    email?: string;
+    public?: boolean;
+    role?: string;
+    displayName?: string;
+  };
+};
+
 export class Api extends Fetcher {
+  private sessionId?: string;
+  private _user?: Prismeai.User & { sessionId?: string };
+
+  get user() {
+    return this._user;
+  }
+
   async me() {
-    return await this.get('/me');
+    const me = await this.get('/me');
+    this.sessionId = me.sessionId;
+    this._user = me;
+    return me;
   }
 
   async signin(
@@ -26,17 +47,38 @@ export class Api extends Fetcher {
       token: string;
     }
   > {
-    return await this.post('/login', {
+    const user = await this.post<
+      Prismeai.User & {
+        token: string;
+      }
+    >('/login', {
       email,
       password,
     });
+    this._user = user;
+    return user;
+  }
+
+  async createAnonymousSession(): Promise<
+    Prismeai.User & {
+      token: string;
+    }
+  > {
+    const user = await this.post<
+      Prismeai.User & {
+        token: string;
+      }
+    >('/login/anonymous');
+    this._user = user;
+    return user;
   }
 
   async signup(
     email: string,
     password: string,
     firstName: string,
-    lastName: string
+    lastName: string,
+    language: string
   ): Promise<
     Prismeai.User & {
       token: string;
@@ -47,6 +89,7 @@ export class Api extends Fetcher {
       password,
       firstName,
       lastName,
+      language,
     });
   }
 
@@ -55,20 +98,66 @@ export class Api extends Fetcher {
     this.token = null;
   }
 
+  // Mail validation
+  async sendValidationMail(email: string, language: string) {
+    return await this.post('/user/validate', { email, language });
+  }
+
+  async validateMail(token: string) {
+    return await this.post('/user/validate', { token });
+  }
+
+  // Password reset
+  async sendPasswordResetMail(email: string, language: string) {
+    return await this.post('/user/password', { email, language });
+  }
+
+  async passwordReset(token: string, password: string) {
+    return await this.post('/user/password', { token, password });
+  }
+
   // Workspaces
   async getWorkspaces(): Promise<Workspace[]> {
-    return await this.get('/workspaces?limit=300');
+    return await this.get('/workspaces?limit=600');
   }
 
-  async getWorkspace(id: string): Promise<Workspace | null> {
+  async getWorkspace(
+    id: string
+  ): Promise<PrismeaiAPI.GetWorkspace.Responses.$200> {
     return await this.get(`/workspaces/${id}`);
   }
 
+  async getWorkspaceSecurity(
+    id: string
+  ): Promise<PrismeaiAPI.GetSecurity.Responses.$200> {
+    return await this.get(`/workspaces/${id}/security`);
+  }
+
+  async updateWorkspaceSecurity(
+    workspaceId: string,
+    security: Prismeai.WorkspaceSecurity
+  ): Promise<PrismeaiAPI.UpdateSecurity.Responses.$200> {
+    return await this.put(`/workspaces/${workspaceId}/security`, security);
+  }
+
+  async getWorkspaceRoles(
+    id: string
+  ): Promise<PrismeaiAPI.GetRoles.Responses.$200> {
+    return await this.get(`/workspaces/${id}/security/roles`);
+  }
+
   async createWorkspace(name: string): Promise<Workspace> {
     return await this.post('/workspaces', { name });
   }
 
-  async updateWorkspace(workspace: Workspace): Promise<Workspace> {
+  async duplicateWorkspace({ id }: { id: string }): Promise<Workspace | null> {
+    return await this.post(`/workspaces/${id}/versions/current/duplicate`, {});
+  }
+
+  async updateWorkspace(
+    workspace: Prismeai.DSULPatch
+  ): Promise<PrismeaiAPI.UpdateWorkspace.Responses.$200 | null> {
+    if (!workspace.id) return null;
     return await this.patch(
       `/workspaces/${workspace.id}`,
       await this.replaceAllImagesData(workspace, workspace.id)
@@ -79,29 +168,89 @@ export class Api extends Fetcher {
     return await this.delete(`/workspaces/${workspaceId}`);
   }
 
+  async generateApiKey(
+    workspaceId: Workspace['id'],
+    events: string[],
+    uploads?: string[]
+  ) {
+    const { apiKey } = await this.post<{ apiKey: string }>(
+      `/workspaces/${workspaceId}/apiKeys`,
+      {
+        rules: {
+          events: {
+            types: events,
+            filters: {
+              'source.sessionId': '${user.sessionId}',
+            },
+          },
+          uploads: uploads
+            ? {
+                mimetypes: uploads,
+              }
+            : undefined,
+        },
+      }
+    );
+
+    return apiKey;
+  }
+  async updateApiKey(
+    workspaceId: Workspace['id'],
+    apiKey: string,
+    events: string[],
+    uploads?: string[]
+  ) {
+    await this.put(`/workspaces/${workspaceId}/apiKeys/${apiKey}`, {
+      rules: {
+        events: {
+          types: events,
+          filters: {
+            'source.sessionId': '${user.sessionId}',
+          },
+        },
+        uploads: uploads
+          ? {
+              mimetypes: uploads,
+            }
+          : undefined,
+      },
+    });
+
+    return apiKey;
+  }
+
   // Automations
+  async getAutomation(
+    workspaceId: string,
+    automationSlug: string
+  ): Promise<PrismeaiAPI.GetAutomation.Responses.$200> {
+    return await this.get(
+      `/workspaces/${workspaceId}/automations/${automationSlug}`
+    );
+  }
+
   async createAutomation(
-    workspace: Workspace,
+    workspaceId: Workspace['id'],
     automation: Prismeai.Automation
   ): Promise<Prismeai.Automation & { slug: string }> {
-    return await this.post(`/workspaces/${workspace.id}/automations`, {
+    return await this.post(`/workspaces/${workspaceId}/automations`, {
       ...automation,
     });
   }
 
   async updateAutomation(
-    workspace: Workspace,
+    workspaceId: string,
     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)
+      `/workspaces/${workspaceId}/automations/${slug}`,
+      await this.replaceAllImagesData(automation, workspaceId)
     );
   }
 
-  async deleteAutomation(workspace: Workspace, slug: string): Promise<string> {
-    return await this.delete(`/workspaces/${workspace.id}/automations/${slug}`);
+  async deleteAutomation(workspaceId: string, slug: string): Promise<string> {
+    return await this.delete(`/workspaces/${workspaceId}/automations/${slug}`);
   }
 
   // Pages
@@ -122,77 +271,92 @@ export class Api extends Fetcher {
 
   async getPage(
     workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId,
-    pageId: PrismeaiAPI.GetPage.Parameters.Id
+    pageSlug: PrismeaiAPI.GetPage.Parameters.Slug
   ): Promise<Prismeai.DetailedPage> {
-    return await this.get(`/workspaces/${workspaceId}/pages/${pageId}`);
+    return await this.get(
+      `/workspaces/${workspaceId}/pages/${encodeURIComponent(pageSlug)}`
+    );
   }
 
   async getPageBySlug(
-    pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.Slug
+    workspaceSlug: PrismeaiAPI.GetPageBySlug.Parameters.WorkspaceSlug,
+    pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.PageSlug
   ): Promise<Prismeai.DetailedPage> {
-    return await this.get(`/pages/${pageSlug}`);
+    return await this.get(
+      `/pages/${workspaceSlug}/${encodeURIComponent(pageSlug)}`
+    );
   }
 
   async createPage(
-    workspaceId: NonNullable<Workspace['id']>,
-    page: Prismeai.Page
+    workspaceId: PrismeaiAPI.CreatePage.Parameters.WorkspaceId,
+    page: PrismeaiAPI.CreatePage.RequestBody
   ): Promise<Prismeai.Page> {
-    const {
-      createdAt,
-      createdBy,
-      updatedAt,
-      updatedBy,
-      ...newPage
-    } = await this.post<PageWithMetadata>(
-      `/workspaces/${workspaceId}/pages`,
-      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
+    workspaceId: PrismeaiAPI.UpdatePage.Parameters.WorkspaceId,
+    page: PrismeaiAPI.UpdatePage.RequestBody,
+    prevSlug: PrismeaiAPI.DeletePage.Parameters.Slug = page.slug || ''
   ): Promise<Prismeai.Page> {
-    const {
-      createdAt,
-      createdBy,
-      updatedAt,
-      updatedBy,
-      ...updatedPage
-    } = await this.patch<PageWithMetadata>(
-      `/workspaces/${workspaceId}/pages/${page.id}`,
-      await this.replaceAllImagesData(page, workspaceId)
-    );
+    const { createdAt, createdBy, updatedAt, updatedBy, ...updatedPage } =
+      await this.patch<PageWithMetadata>(
+        `/workspaces/${workspaceId}/pages/${encodeURIComponent(prevSlug)}`,
+        // Replace images as dataurl to uploaded url in any type of data
+        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}`);
+    workspaceId: PrismeaiAPI.DeletePage.Parameters.WorkspaceId,
+    pageSlug: PrismeaiAPI.DeletePage.Parameters.Slug
+  ): Promise<PrismeaiAPI.DeletePage.Responses.$200> {
+    return await this.delete(
+      `/workspaces/${workspaceId}/pages/${encodeURIComponent(pageSlug)}`
+    );
   }
 
   // Events
-  streamEvents(workspaceId: string): Promise<Events> {
-    const events = new Events(workspaceId, this.token || '', this.host);
+  streamEvents(
+    workspaceId: string,
+    filters?: Record<string, any>
+  ): Promise<Events> {
+    if (filters && filters['source.sessionId'] === true) {
+      if (this.sessionId) {
+        filters['source.sessionId'] = this.sessionId;
+      } else {
+        delete filters['source.sessionId'];
+      }
+    }
+    const events = new Events({
+      workspaceId,
+      token: this.token || '',
+      apiKey: this._apiKey ? this._apiKey : undefined,
+      apiHost: this.host,
+      filters,
+      api: this,
+    });
     return new Promise((resolve, reject) => {
-      events.once('connect', () => {
-        resolve(events);
-      });
-      events.once('connect_error', () => {
+      const off = events.once('connect_error', () => {
         reject();
         events.close();
       });
+      events.once('connect', () => {
+        off();
+        resolve(events);
+      });
     });
   }
 
   async getEvents(
     workspaceId: string,
-    options: { beforeDate?: Date | string } = {}
+    options: Record<string, any> = {}
   ): Promise<Event<Date>[]> {
     try {
       const query = QueryString.stringify(options);
@@ -229,32 +393,89 @@ export class Api extends Fetcher {
     }
   }
 
+  async findContacts(
+    query: PrismeaiAPI.FindContacts.RequestBody
+  ): Promise<PrismeaiAPI.FindContacts.Responses.$200> {
+    return await this.post(`/contacts`, query);
+  }
+
   async getPermissions(
     subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType,
     subjectId: string
-  ): Promise<PrismeaiAPI.GetPermissions.Responses.$200> {
-    return await this.get(`/${subjectType}/${subjectId}/permissions`);
+  ): Promise<{ result: UserPermissions[] }> {
+    const permissions: PrismeaiAPI.GetPermissions.Responses.$200 =
+      await this.get(`/${subjectType}/${subjectId}/permissions`);
+    const contacts = await this.findContacts({
+      ids: permissions.result
+        .filter((cur) => cur.target.id && !cur.target.displayName)
+        .map((cur) => cur.target.id!),
+    });
+    return {
+      result: permissions.result.map((perm) => {
+        const user =
+          perm.target.id && !perm.target.displayName
+            ? contacts.contacts.find((cur) => cur.id === perm.target.id)
+            : undefined;
+        const displayName =
+          perm.target.displayName || `${user?.firstName} ${user?.lastName}`;
+        return {
+          ...perm,
+          target: {
+            ...perm.target,
+            id: perm.target.id!,
+            displayName,
+          },
+        };
+      }),
+    };
   }
 
   async addPermissions(
     subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType,
     subjectId: string,
     permissions: UserPermissions
-  ): Promise<PrismeaiAPI.Share.Responses.$200> {
-    return await this.post(
+  ): Promise<UserPermissions> {
+    const body = { ...permissions };
+    const { email } = permissions.target;
+
+    if (email) {
+      const contacts = await this.findContacts({
+        email,
+      });
+
+      if (!contacts.contacts.length) {
+        throw new ApiError(
+          {
+            error: 'CollaboratorNotFound',
+            message: 'This user does not exist',
+            details: { email },
+          },
+          404
+        );
+      }
+      body.target = { id: contacts.contacts[0].id };
+    }
+
+    const result: PrismeaiAPI.Share.Responses.$200 = await this.post(
       `/${subjectType}/${subjectId}/permissions`,
-      permissions
+      body
     );
+    return {
+      ...result,
+      target: {
+        ...result.target,
+        id: result.target.id!,
+        email,
+      },
+    };
   }
 
   async deletePermissions(
     subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType,
     subjectId: string,
-    userEmail: string
+    id: string
   ): Promise<PrismeaiAPI.RevokePermissions.Responses.$200> {
-    return await this.delete(
-      `/${subjectType}/${subjectId}/permissions/${userEmail}`
-    );
+    return await this.delete(`/${subjectType}/${subjectId}/permissions/${id}`);
   }
 
   async getApps({
@@ -271,7 +492,7 @@ export class Api extends Fetcher {
     const params = new URLSearchParams(
       removedUndefinedProperties(
         {
-          text: `${query || ''}`,
+          text: `${encodeURIComponent(query || '')}`,
           page: `${page || ''}`,
           limit: `${limit || ''}`,
           workspaceId: `${workspaceId || ''}`,
@@ -316,12 +537,6 @@ export class Api extends Fetcher {
     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
@@ -344,6 +559,25 @@ export class Api extends Fetcher {
     return config;
   }
 
+  async getAppInstance(
+    workspaceId: string,
+    slug: string
+  ): Promise<PrismeaiAPI.GetAppInstance.Responses.$200> {
+    return this.get(`/workspaces/${workspaceId}/apps/${slug}`);
+  }
+
+  async saveAppInstance(
+    workspaceId: PrismeaiAPI.ConfigureAppInstance.Parameters.WorkspaceId,
+    slug: PrismeaiAPI.ConfigureAppInstance.Parameters.Slug,
+    appInstance: PrismeaiAPI.ConfigureAppInstance.RequestBody
+  ): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200> {
+    const response = await this.patch<Prismeai.DetailedAppInstance>(
+      `/workspaces/${workspaceId}/apps/${slug}`,
+      { ...appInstance }
+    );
+    return response;
+  }
+
   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
@@ -351,7 +585,6 @@ export class Api extends Fetcher {
       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(';')
@@ -372,9 +605,10 @@ export class Api extends Fetcher {
     }
     const formData = new FormData();
     (Array.isArray(files) ? files : [files]).forEach((file) => {
-      formData.append('file', ...dataURItoBlob(file));
+      try {
+        formData.append('file', ...dataURItoBlob(file));
+      } catch {}
     });
-
     try {
       return await this._fetch<PrismeaiAPI.UploadFile.Responses.$200>(
         `/workspaces/${workspaceId}/files`,
@@ -431,8 +665,45 @@ export class Api extends Fetcher {
     return replaced;
   }
 
-  async callAutomation(workspaceId: string, automation: string): Promise<any> {
-    return this._fetch(`/workspaces/${workspaceId}/webhooks/${automation}`);
+  async callAutomation(
+    workspaceId: string,
+    automation: string,
+    params?: any
+  ): Promise<any> {
+    return this.post(
+      `/workspaces/${workspaceId}/webhooks/${automation}`,
+      params
+    );
+  }
+
+  async getWorkspaceUsage(
+    workspaceId: PrismeaiAPI.WorkspaceUsage.Parameters.WorkspaceId,
+    {
+      afterDate,
+      beforeDate,
+      details,
+    }: {
+      afterDate?: PrismeaiAPI.WorkspaceUsage.Parameters.AfterDate;
+      beforeDate?: PrismeaiAPI.WorkspaceUsage.Parameters.BeforeDate;
+      details?: PrismeaiAPI.WorkspaceUsage.Parameters.Details;
+    } = {}
+  ): Promise<PrismeaiAPI.WorkspaceUsage.Responses.$200> {
+    const params = new URLSearchParams(
+      removedUndefinedProperties(
+        {
+          afterDate: `${afterDate || ''}`,
+          beforeDate: `${beforeDate || ''}`,
+          details: `${details || ''}`,
+        },
+        true
+      )
+    );
+
+    return this.get(`/workspaces/${workspaceId}/usage?${params.toString()}`);
+  }
+
+  workspaces(id: string) {
+    return new WorkspacesEndpoint(id, this);
   }
 }
 

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;