@prisme.ai/sdk 1.0.0 → 1.0.1

package/lib/api.ts

@@ -1,10 +1,12 @@
 import QueryString from 'qs';
-import Fetcher from './fetcher';
+import pkceChallenge from 'pkce-challenge';
+import Fetcher, { Fetched } from './fetcher';
 import { Event, Workspace } from './types';
 import { Events } from './events';
 import { removedUndefinedProperties } from './utils';
 import WorkspacesEndpoint from './endpoints/workspaces';
 import ApiError from './ApiError';
+import UsersEndpoint from './endpoints/users';
 
 interface PageWithMetadata extends Prismeai.Page {
   createdAt: string;
@@ -24,10 +26,74 @@ export type UserPermissions = {
   };
 };
 
+export interface ApiOptions {
+  host: string;
+  oidc?: {
+    url: string;
+    clientId: string;
+    clientIdHeader?: string;
+    redirectUri: string;
+  };
+}
+
+export interface AccessToken {
+  access_token: string;
+  id_token: string;
+  scope: string;
+  expiresIn: number;
+  token_type: 'Bearer';
+}
+
+export interface InteractiveSignin {
+  interaction: string;
+  login: string;
+  password: string;
+  remember?: boolean;
+}
+
+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];
+}
+
 export class Api extends Fetcher {
+  public opts: Required<ApiOptions>;
   private sessionId?: string;
   private _user?: Prismeai.User & { sessionId?: string };
 
+  constructor(opts: ApiOptions) {
+    super(opts.host, opts?.oidc?.clientIdHeader);
+    this.opts = {
+      ...opts,
+      oidc: {
+        url: 'http://studio.local.prisme.ai:3001',
+        clientId: 'local-client-id',
+        redirectUri: 'http://studio.local.prisme.ai:3000/signin',
+        ...opts.oidc,
+      },
+    };
+  }
+
   get user() {
     return this._user;
   }
@@ -39,24 +105,85 @@ export class Api extends Fetcher {
     return me;
   }
 
-  async signin(
-    email: string,
-    password: string
-  ): Promise<
-    Prismeai.User & {
-      token: string;
+  clientId(): string {
+    return this.overwriteClientId || this.opts?.oidc?.clientId;
+  }
+
+  async getAuthorizationURL(
+    overrideRedirectUri?: string,
+    authParams?: { max_age?: string; acr_values?: string },
+    locale = window?.navigator?.language
+      ? window.navigator.language.substring(0, 2)
+      : undefined
+  ) {
+    const url = new URL('/oidc/auth', this.opts.oidc.url);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('response_mode', 'query'); // Send the final authorization code as a query param to the redirect uri
+    url.searchParams.set(
+      'redirect_uri',
+      overrideRedirectUri || this.opts.oidc?.redirectUri || ''
+    );
+    url.searchParams.set(
+      'scope',
+      'openid profile email settings offline_access events:write events:read webhooks pages:read files:write files:read'
+    );
+    const clientId = this.clientId();
+    url.searchParams.set('client_id', clientId);
+
+    url.searchParams.set('code_challenge_method', 'S256');
+    const { code_verifier: codeVerifier, code_challenge: codeChallenge } =
+      await pkceChallenge(64);
+    url.searchParams.set('code_challenge', codeChallenge);
+    if (locale) {
+      url.searchParams.set('locale', locale);
     }
-  > {
-    const user = await this.post<
-      Prismeai.User & {
-        token: string;
-      }
-    >('/login', {
-      email,
-      password,
+
+    Object.entries(authParams || {}).forEach(([k, v]) => {
+      url.searchParams.set(k, v);
     });
-    this._user = user;
-    return user;
+
+    return {
+      url: url.toString(),
+      codeVerifier,
+      clientId,
+    };
+  }
+
+  async signin(body: InteractiveSignin): Promise<{ redirectTo: string }> {
+    const url = new URL(
+      `/oidc/interaction/${body.interaction}/login`,
+      this.opts.oidc.url
+    );
+
+    // Do not follow redirects as we need to get redirected from browser itself to save final token in local storage
+    await this.post(url.toString(), new URLSearchParams(body as any), {
+      redirect: 'manual',
+    });
+    const redirectTo = new URL(
+      `/oidc/auth/${body.interaction}`,
+      this.opts.oidc.url
+    );
+    return { redirectTo: redirectTo.toString() };
+  }
+
+  async getToken(
+    authorizationCode: string,
+    codeVerifier: string,
+    overrideRedirectUri?: string
+  ): Promise<AccessToken> {
+    this.token = null;
+    const url = new URL('/oidc/token', this.opts.oidc.url);
+    const token = await this.post<AccessToken>(
+      url.toString(),
+      new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: authorizationCode,
+        code_verifier: codeVerifier,
+        client_id: this.clientId(),
+        redirect_uri: overrideRedirectUri || this.opts.oidc.redirectUri,
+      })
+    );
+    return token;
   }
 
   async createAnonymousSession(): Promise<
@@ -68,7 +195,13 @@ export class Api extends Fetcher {
       Prismeai.User & {
         token: string;
       }
-    >('/login/anonymous');
+    >(
+      '/login/anonymous',
+      {},
+      {
+        credentials: 'omit',
+      }
+    );
     this._user = user;
     return user;
   }
@@ -93,9 +226,17 @@ export class Api extends Fetcher {
     });
   }
 
-  async signout() {
-    await this.post('/logout');
-    this.token = null;
+  getSignoutURL(redirectUri?: string) {
+    const params = new URLSearchParams();
+    params.set('client_id', this.clientId());
+    if (redirectUri) {
+      params.set('post_logout_redirect_uri', redirectUri);
+    }
+    const url = new URL(
+      `/oidc/session/end?${params.toString()}`,
+      this.opts.oidc.url
+    );
+    return url.toString();
   }
 
   // Mail validation
@@ -136,13 +277,13 @@ export class Api extends Fetcher {
   async updateWorkspaceSecurity(
     workspaceId: string,
     security: Prismeai.WorkspaceSecurity
-  ): Promise<PrismeaiAPI.UpdateSecurity.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.UpdateSecurity.Responses.$200>> {
     return await this.put(`/workspaces/${workspaceId}/security`, security);
   }
 
   async getWorkspaceRoles(
     id: string
-  ): Promise<PrismeaiAPI.GetRoles.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.GetRoles.Responses.$200>> {
     return await this.get(`/workspaces/${id}/security/roles`);
   }
 
@@ -156,7 +297,7 @@ export class Api extends Fetcher {
 
   async updateWorkspace(
     workspace: Prismeai.DSULPatch
-  ): Promise<PrismeaiAPI.UpdateWorkspace.Responses.$200 | null> {
+  ): Promise<Fetched<PrismeaiAPI.UpdateWorkspace.Responses.$200> | null> {
     if (!workspace.id) return null;
     return await this.patch(
       `/workspaces/${workspace.id}`,
@@ -223,7 +364,7 @@ export class Api extends Fetcher {
   async getAutomation(
     workspaceId: string,
     automationSlug: string
-  ): Promise<PrismeaiAPI.GetAutomation.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.GetAutomation.Responses.$200>> {
     return await this.get(
       `/workspaces/${workspaceId}/automations/${automationSlug}`
     );
@@ -232,7 +373,7 @@ export class Api extends Fetcher {
   async createAutomation(
     workspaceId: Workspace['id'],
     automation: Prismeai.Automation
-  ): Promise<Prismeai.Automation & { slug: string }> {
+  ): Promise<Fetched<Prismeai.Automation & { slug: string }>> {
     return await this.post(`/workspaces/${workspaceId}/automations`, {
       ...automation,
     });
@@ -242,7 +383,7 @@ export class Api extends Fetcher {
     workspaceId: string,
     slug: string,
     automation: Prismeai.Automation
-  ): Promise<Prismeai.Automation & { slug: string }> {
+  ): Promise<Fetched<Prismeai.Automation & { slug: string }>> {
     return await this.patch(
       `/workspaces/${workspaceId}/automations/${slug}`,
       await this.replaceAllImagesData(automation, workspaceId)
@@ -272,7 +413,7 @@ export class Api extends Fetcher {
   async getPage(
     workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId,
     pageSlug: PrismeaiAPI.GetPage.Parameters.Slug
-  ): Promise<Prismeai.DetailedPage> {
+  ): Promise<Fetched<Prismeai.DetailedPage>> {
     return await this.get(
       `/workspaces/${workspaceId}/pages/${encodeURIComponent(pageSlug)}`
     );
@@ -281,7 +422,7 @@ export class Api extends Fetcher {
   async getPageBySlug(
     workspaceSlug: PrismeaiAPI.GetPageBySlug.Parameters.WorkspaceSlug,
     pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.PageSlug
-  ): Promise<Prismeai.DetailedPage> {
+  ): Promise<Fetched<Prismeai.DetailedPage>> {
     return await this.get(
       `/pages/${workspaceSlug}/${encodeURIComponent(pageSlug)}`
     );
@@ -316,7 +457,7 @@ export class Api extends Fetcher {
   async deletePage(
     workspaceId: PrismeaiAPI.DeletePage.Parameters.WorkspaceId,
     pageSlug: PrismeaiAPI.DeletePage.Parameters.Slug
-  ): Promise<PrismeaiAPI.DeletePage.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.DeletePage.Responses.$200>> {
     return await this.delete(
       `/workspaces/${workspaceId}/pages/${encodeURIComponent(pageSlug)}`
     );
@@ -337,6 +478,7 @@ export class Api extends Fetcher {
     const events = new Events({
       workspaceId,
       token: this.token || '',
+      legacyToken: this.legacyToken || '',
       apiKey: this._apiKey ? this._apiKey : undefined,
       apiHost: this.host,
       filters,
@@ -474,7 +616,7 @@ export class Api extends Fetcher {
     subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType,
     subjectId: string,
     id: string
-  ): Promise<PrismeaiAPI.RevokePermissions.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.RevokePermissions.Responses.$200>> {
     return await this.delete(`/${subjectType}/${subjectId}/permissions/${id}`);
   }
 
@@ -488,7 +630,7 @@ export class Api extends Fetcher {
     page?: PrismeaiAPI.SearchApps.QueryParameters['page'];
     limit?: PrismeaiAPI.SearchApps.QueryParameters['limit'];
     workspaceId?: PrismeaiAPI.SearchApps.QueryParameters['workspaceId'];
-  }): Promise<PrismeaiAPI.SearchApps.Responses.$200> {
+  }): Promise<Fetched<PrismeaiAPI.SearchApps.Responses.$200>> {
     const params = new URLSearchParams(
       removedUndefinedProperties(
         {
@@ -506,7 +648,7 @@ export class Api extends Fetcher {
   async installApp(
     workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'],
     body: PrismeaiAPI.InstallAppInstance.RequestBody
-  ): Promise<PrismeaiAPI.InstallAppInstance.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.InstallAppInstance.Responses.$200>> {
     return await this.post(`/workspaces/${workspaceId}/apps`, body);
   }
 
@@ -514,26 +656,26 @@ export class Api extends Fetcher {
     workspaceId: PrismeaiAPI.ConfigureAppInstance.PathParameters['workspaceId'],
     slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug'],
     body: PrismeaiAPI.ConfigureAppInstance.RequestBody
-  ): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200> {
+  ): Promise<Fetched<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> {
+  ): Promise<Fetched<PrismeaiAPI.UninstallAppInstance.Responses.$200>> {
     return await this.delete(`/workspaces/${workspaceId}/apps/${slug}`);
   }
 
   async publishApp(
     body: PrismeaiAPI.PublishApp.RequestBody
-  ): Promise<PrismeaiAPI.PublishApp.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.PublishApp.Responses.$200>> {
     return await this.post(`/apps`, body);
   }
 
   async listAppInstances(
     workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']
-  ): Promise<PrismeaiAPI.ListAppInstances.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.ListAppInstances.Responses.$200>> {
     return await this.get(`/workspaces/${workspaceId}/apps`);
   }
 
@@ -562,7 +704,7 @@ export class Api extends Fetcher {
   async getAppInstance(
     workspaceId: string,
     slug: string
-  ): Promise<PrismeaiAPI.GetAppInstance.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.GetAppInstance.Responses.$200>> {
     return this.get(`/workspaces/${workspaceId}/apps/${slug}`);
   }
 
@@ -570,7 +712,7 @@ export class Api extends Fetcher {
     workspaceId: PrismeaiAPI.ConfigureAppInstance.Parameters.WorkspaceId,
     slug: PrismeaiAPI.ConfigureAppInstance.Parameters.Slug,
     appInstance: PrismeaiAPI.ConfigureAppInstance.RequestBody
-  ): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.ConfigureAppInstance.Responses.$200>> {
     const response = await this.patch<Prismeai.DetailedAppInstance>(
       `/workspaces/${workspaceId}/apps/${slug}`,
       { ...appInstance }
@@ -579,30 +721,6 @@ export class Api extends Fetcher {
   }
 
   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) => {
       try {
@@ -669,13 +787,27 @@ export class Api extends Fetcher {
     workspaceId: string,
     automation: string,
     params?: any
-  ): Promise<any> {
+  ): Promise<Fetched<any>> {
     return this.post(
       `/workspaces/${workspaceId}/webhooks/${automation}`,
       params
     );
   }
 
+  async testAutomation({
+    workspaceId,
+    automation,
+    payload,
+  }: {
+    workspaceId: string;
+    automation: string;
+    payload?: Record<string, any>;
+  }): Promise<Fetched<any>> {
+    return this.post(`/workspaces/${workspaceId}/test/${automation}`, {
+      payload,
+    });
+  }
+
   async getWorkspaceUsage(
     workspaceId: PrismeaiAPI.WorkspaceUsage.Parameters.WorkspaceId,
     {
@@ -687,7 +819,7 @@ export class Api extends Fetcher {
       beforeDate?: PrismeaiAPI.WorkspaceUsage.Parameters.BeforeDate;
       details?: PrismeaiAPI.WorkspaceUsage.Parameters.Details;
     } = {}
-  ): Promise<PrismeaiAPI.WorkspaceUsage.Responses.$200> {
+  ): Promise<Fetched<PrismeaiAPI.WorkspaceUsage.Responses.$200>> {
     const params = new URLSearchParams(
       removedUndefinedProperties(
         {
@@ -702,9 +834,38 @@ export class Api extends Fetcher {
     return this.get(`/workspaces/${workspaceId}/usage?${params.toString()}`);
   }
 
+  async importArchive(
+    archive: File
+  ): Promise<PrismeaiAPI.ImportNewWorkspace.Responses.$200> {
+    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));
+        resolve(
+          await this._fetch<PrismeaiAPI.ImportNewWorkspace.Responses.$200>(
+            `/workspaces/import`,
+            {
+              method: 'POST',
+              body: formData,
+            }
+          )
+        );
+      });
+      fileReader.readAsDataURL(archive);
+    });
+  }
+
+  users(id: string = this.user?.id || '') {
+    if (!id) {
+      throw new Error();
+    }
+    return new UsersEndpoint(id, this);
+  }
   workspaces(id: string) {
     return new WorkspacesEndpoint(id, this);
   }
 }
 
-export default new Api('https://api.eda.prisme.ai');
+export default new Api({ host: 'https://api.eda.prisme.ai' });

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/events.test.ts

@@ -21,7 +21,7 @@ it('should connect to Websocket', () => {
     `https://api.eda.prisme.ai/workspaces/1/events`,
     {
       extraHeaders: {
-        'x-prismeai-token': 'abcde',
+        Authorization: 'Bearer abcde',
       },
       withCredentials: true,
     }
@@ -39,7 +39,7 @@ it('should connect to Websocket with apiKey', () => {
     `https://api.eda.prisme.ai/workspaces/1/events`,
     {
       extraHeaders: {
-        'x-prismeai-token': 'abcde',
+        Authorization: 'Bearer abcde',
         'x-prismeai-api-key': 'fghij',
       },
       withCredentials: true,

package/lib/events.ts

@@ -24,6 +24,7 @@ export class Events {
   constructor({
     workspaceId,
     token,
+    legacyToken,
     apiKey,
     apiHost = 'https://api.eda.prisme.ai',
     filters,
@@ -31,6 +32,7 @@ export class Events {
   }: {
     workspaceId: string;
     token: string;
+    legacyToken?: string;
     apiKey?: string;
     apiHost?: string;
     filters?: Record<string, any>;
@@ -39,9 +41,11 @@ export class Events {
     this.workspaceId = workspaceId;
     const queryString = new URLSearchParams(filters || {}).toString();
     const fullQueryString = queryString ? `?${queryString}` : '';
-    const extraHeaders: any = {
-      'x-prismeai-token': token,
-    };
+    const extraHeaders: any = token
+      ? {
+          Authorization: `Bearer ${token}`,
+        }
+      : { 'x-prismeai-token': legacyToken };
     this.lastReceivedEventDate = new Date();
     if (apiKey) {
       extraHeaders['x-prismeai-api-key'] = apiKey;

package/lib/fetcher.ts

@@ -10,26 +10,36 @@ 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;
   }
 
   set apiKey(apiKey: string) {
     this._apiKey = apiKey;
   }
 
-  prepareRequest(url: string,
-    options: RequestInit = {}) {
+  prepareRequest(url: string, options: RequestInit = {}) {
     const headers = new Headers(options.headers || {});
 
-    if (this.token && !headers.has('x-prismeai-token')) {
-      headers.append('x-prismeai-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')) {
@@ -40,6 +50,10 @@ export class Fetcher {
       headers.append('accept-language', this.language);
     }
 
+    if (options.body instanceof URLSearchParams) {
+      headers.set('Content-Type', 'application/x-www-form-urlencoded');
+    }
+
     if (
       (!options.body || !(options.body instanceof FormData)) &&
       !headers.has('Content-Type')
@@ -47,9 +61,12 @@ export class Fetcher {
       headers.append('Content-Type', 'application/json');
     }
 
-    headers.append('Access-Control-Allow-Origin', '*');
-
-    return 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,
     });
@@ -60,7 +77,14 @@ export class Fetcher {
     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 {
@@ -102,10 +126,16 @@ 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,
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisme.ai/sdk",
-  "version": "1.0.0",
+  "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"
   }