@tellescope/sdk 0.0.4 → 0.0.8

package/src/sdk.ts

@@ -1,5 +1,3 @@
-import { io } from 'socket.io-client'
-
 import {
   JourneyState, 
   UserSession,
@@ -11,7 +9,9 @@ import {
   ClientModelForName_required,
   ClientModelForName_updatesDisabled,
   Enduser,
+  File,
 } from "@tellescope/types-client"
+import { CustomUpdateOptions, SortOption, S3PresignedPost } from "@tellescope/types-utilities"
 import { url_safe_path } from "@tellescope/utilities"
 
 import { Session as SessionManager, SessionOptions, Filter } from "./session"
@@ -30,29 +30,29 @@ export interface APIQuery<
   createOne: (t: CREATE) => Promise<T>;
   createSome: (ts: CREATE[]) => Promise<{ created: T[], errors: object[] }>;
   getOne: (id: string, filter?: Filter<Partial<T>>) => Promise<T>;
-  getSome: (o?: { lastId?: string, limit?: number, sort?: SortOption, threadKey?: string }, f?: Filter<Partial<T>>) => Promise<T[]>
+  getSome: (o?: { lastId?: string, limit?: number, sort?: SortOption, threadKey?: string, filter?: Filter<Partial<T>> }) => Promise<T[]>
   updateOne: (id: string, updates: UPDATE, options?: CustomUpdateOptions) => Promise<void>;
   deleteOne: (id: string) => Promise<void>;
 }
 
 export const defaultQueries = <N extends keyof ClientModelForName>(
-  s: SessionManager, n: keyof ClientModelForName_required
+  s: Session, n: keyof ClientModelForName_required
 ): APIQuery<N> => {
 
   const safeName = url_safe_path(n)
   const singularName = (safeName).substring(0, safeName.length - 1)
 
   return {
-    createOne: o => s.POST(`/v1/${singularName}`, o),
-    createSome: os => s.POST(`/v1/${safeName}`, { create: os }),
-    getOne: (id, filter) => s.GET(`/v1/${singularName}/${id}`, { filter }),
-    getSome: (o, filter) => s.GET(`/v1/${safeName}`, { ...o, filter }),
-    updateOne: (id, updates, options) => s.PATCH(`/v1/${singularName}/${id}`, { updates, options }),
-    deleteOne: id => s.DELETE(`/v1/${singularName}/${id}`),
+    createOne: o => s._POST(`/v1/${singularName}`, o),
+    createSome: os => s._POST(`/v1/${safeName}`, { create: os }),
+    getOne: (id, filter) => s._GET(`/v1/${singularName}/${id}`, { filter }),
+    getSome: (o) => s._GET(`/v1/${safeName}`, o),
+    updateOne: (id, updates, options) => s._PATCH(`/v1/${singularName}/${id}`, { updates, options }),
+    deleteOne: id => s._DELETE(`/v1/${singularName}/${id}`),
   }
 }
 
-const loadDefaultQueries = (s: SessionManager): { [K in keyof ClientModelForName] : APIQuery<K> } => ({
+const loadDefaultQueries = (s: Session): { [K in keyof ClientModelForName] : APIQuery<K> } => ({
   endusers: defaultQueries(s, 'endusers'),
   engagement_events: defaultQueries(s, 'engagement_events'),
   journeys: defaultQueries(s, 'journeys'),
@@ -63,52 +63,86 @@ const loadDefaultQueries = (s: SessionManager): { [K in keyof ClientModelForName
   chat_rooms: defaultQueries(s, 'chat_rooms'),
   chats: defaultQueries(s, 'chats'),
   users: defaultQueries(s, 'users'),
-  templates: defaultQueries(s, 'templates') ,
+  templates: defaultQueries(s, 'templates'),
+  files: defaultQueries(s, 'files'),
 })
 
 type Queries = { [K in keyof ClientModelForName]: APIQuery<K> } & {
   journeys: {
-    updateState: (id: string, name: string, updates: JourneyState) => Promise<void>
+    updateState: (args: { id: string, name: string, updates: JourneyState }) => Promise<void>
   },
   endusers: {
-    setPassword: (id: string, password: string) => Promise<void>,
-    isAuthenticated: (id: string, authToken: string) => Promise<{ isAuthenticated: boolean, enduser: Enduser }>
-  }
+    setPassword: (args: { id: string, password: string }) => Promise<void>,
+    isAuthenticated: (args: { id: string, authToken: string }) => Promise<{ isAuthenticated: boolean, enduser: Enduser }>
+  },
+  users: {
+    display_names: () => Promise<{ fname: string, lname: string, id: string }[]>,
+  },
+  files: {
+    prepare_file_upload: (args: { name: string, size: number, type: string }) => Promise<{ presignedUpload: S3PresignedPost, file: File }>,
+    file_download_URL: (args: { secureName: string }) => Promise<{ downloadURL: string }>,
+  },
 }
 
-export class Session extends SessionManager{
+export class Session extends SessionManager {
   api: Queries;
-  userInfo: UserSession;
+  userInfo!: UserSession;
 
   constructor(o?: SessionOptions) {
-    super(o)
-    this.userInfo = {} as UserSession
+    super({ ...o, cacheKey: o?.cacheKey || "tellescope_user" })
     const queries = loadDefaultQueries(this) as Queries
 
-    queries.journeys.updateState = (id, name, updates) => this.PATCH(`/v1/journey/${id}/state/${name}`, { updates })
-    queries.endusers.setPassword = (id, password) => this.POST(`/v1/set-enduser-password`, { id, password })
-    queries.endusers.isAuthenticated = (id, authToken) => this.GET(`/v1/enduser-is-authenticated`, { id, authToken })
+    queries.journeys.updateState = ({id, name, updates}) => this._PATCH(`/v1/journey/${id}/state/${name}`, { updates })
+    queries.endusers.setPassword = ({id, password}) => this._POST(`/v1/set-enduser-password`, { id, password })
+    queries.endusers.isAuthenticated = ({id, authToken}) => this._GET(`/v1/enduser-is-authenticated`, { id, authToken })
+    queries.users.display_names = () => this._GET<{}, { fname: string, lname: string, id: string }[]>(`/v1/user-display-names`),
+    queries.files.prepare_file_upload = (args) => this._POST(`/v1/prepare-file-upload`, args),
+    queries.files.file_download_URL = a => this._GET('/v1/file-download-URL', a),
 
     this.api = queries
+
+    // if (this.userInfo) this.refresh_session()
   }
 
+  _POST = async <A,R=void>(endpoint: string, args?: A, authenticated=true) => {
+    await this.refresh_session_if_expiring_soon()
+    return await this.POST<A,R>(endpoint, args, authenticated)
+  }
 
-  handle_new_session = async ({ authToken, ...userInfo }:   UserSession & { authToken: string }) => {
-    this.setAuthToken(authToken)
-    this.userInfo = userInfo
+  _GET = async <A,R=void>(endpoint: string, params?: A, authenticated=true) => {
+    await this.refresh_session_if_expiring_soon()
+    return await this.GET<A,R>(endpoint, params, authenticated)
+  }
 
-    this.socket = io(`${this.host}/${userInfo.organization}`, { transports: ['websocket'] }); // supporting polling requires sticky session at load balancer
-    this.socket.on('disconnect', () => { this.socketAuthenticated = false })
-    this.socket.on('authenticated', () => { this.socketAuthenticated = true })
+  _PATCH = async <A,R=void>(endpoint: string, params?: A, authenticated=true) => {
+    await this.refresh_session_if_expiring_soon()
+    return await this.PATCH<A,R>(endpoint, params, authenticated)
+  }
 
-    this.socket.emit('authenticate', authToken)
+  _DELETE = async <A,R=void>(endpoint: string, args?: A, authenticated=true) => {
+    await this.refresh_session_if_expiring_soon()
+    return await this.DELETE<A,R>(endpoint, args, authenticated)
+  }
+ 
+  handle_new_session = async ({ authToken, ...userInfo }:   UserSession & { authToken: string }) => {
+    this.sessionStart = Date.now()
+    this.setAuthToken(authToken)
+    this.setUserInfo(userInfo)
+    this.authenticate_socket()
 
     return { authToken, ...userInfo }
   }
 
   refresh_session = async () => {
-    const { userInfo, authToken } = await this.GET<{}, { userInfo: UserSession } & { authToken: string }>('/refresh-session')
-    await this.handle_new_session({ ...userInfo, authToken })
+    console.log('refreshing session')
+    const { user, authToken } = await this.POST<{}, { user: UserSession } & { authToken: string }>('/v1/refresh-session')
+    await this.handle_new_session({ ...user, authToken })
+    return { user, authToken }
+  }
+  refresh_session_if_expiring_soon = async () => {
+    const elapsedSessionMS =  Date.now() - (this.sessionStart || Date.now())
+    
+    if (this.AUTO_REFRESH_MS < elapsedSessionMS) { return await this.refresh_session()}
   }
 
   authenticate = async (email: string, password: string, url?: string) => {
@@ -118,17 +152,11 @@ export class Session extends SessionManager{
       await this.POST<{email: string, password: string },  UserSession & { authToken: string }>('/submit-login', { email, password })
     ) 
   }
+  logout = async () => {
+    this.clearState()
+    await this.POST('/logout-api').catch(console.error)
+  }
 
-  subscribe = (rooms: { [index: string]: keyof ClientModelForName } ) => this.EMIT('join-rooms', { rooms })
-
-  handle_events = ( handlers: { [index: string]: (a: any) => void } ) => {
-    for (const handler in handlers) this.ON(handler, handlers[handler])
-  } 
-
-  unsubscribe = (roomIds: string[]) => this.EMIT('leave-rooms', { roomIds })
-
-  socket_is_authenticated = () => this.socketAuthenticated
-  logout = () => this.POST('/logout-api')
   reset_db = () => this.POST('/reset-demo')
   test_online = () => this.GET<{}, string>('/v1')
   test_authenticated = () => this.GET<{}, string>('/v1/test-authenticated')

package/src/session.ts

@@ -1,9 +1,19 @@
 import axios from "axios"
-import { Socket } from 'socket.io-client'
-
-import {  } from "@tellescope/types-models"
-import { ClientModelForName_required, ClientModelForName_readonly, ClientModelForName_updatesDisabled } from "@tellescope/types-client"
-import { url_safe_path } from "@tellescope/utilities"
+import NodeFormData from "form-data"
+import { Socket, io } from 'socket.io-client'
+
+import { 
+  CustomUpdateOptions,
+  FileBlob,
+  SortOption,  
+  S3PresignedPost,
+} from "@tellescope/types-utilities"
+import { 
+  ClientModelForName,
+  ClientModelForName_required, 
+  ClientModelForName_readonly, 
+  ClientModelForName_updatesDisabled 
+} from "@tellescope/types-client"
 
 export const DEFAULT_HOST = 'https://api.tellescope.com'
 
@@ -11,6 +21,12 @@ export interface SessionOptions {
   apiKey?: string;
   authToken?: string;
   host?: string;
+  cacheKey?: string;
+  handleUnauthenticated?: () => Promise<void>;
+}
+
+interface RequestOptions {
+  refresh_session?: () => Promise<any>,
 }
 
 export type Filter<T> = { [K in keyof T]: T[K] }
@@ -31,23 +47,6 @@ export interface APIQuery<
   deleteOne: (id: string) => Promise<void>;
 }
 
-export const defaultQueries = <N extends keyof ClientModelForName>(
-  s: Session, n: keyof ClientModelForName_required
-): APIQuery<N> => {
-
-  const safeName = url_safe_path(n)
-  const singularName = (safeName).substring(0, safeName.length - 1)
-
-  return {
-    createOne: o => s.POST(`/v1/${singularName}`, o),
-    createSome: os => s.POST(`/v1/${safeName}`, { create: os }),
-    getOne: (id, filter) => s.GET(`/v1/${singularName}/${id}`, { filter }),
-    getSome: (o, filter) => s.GET(`/v1/${safeName}`, { ...o, filter }),
-    updateOne: (id, updates, options) => s.PATCH(`/v1/${singularName}/${id}`, { updates, options }),
-    deleteOne: id => s.DELETE(`/v1/${singularName}/${id}`),
-  }
-}
-
 const generateBearer = (authToken: string) => `Bearer ${authToken}`
 
 const parseError = (err: any) => {
@@ -59,32 +58,80 @@ const parseError = (err: any) => {
   return err
 }
 
+const DEFAULT_AUTHTOKEN_KEY = 'tellescope_authToken'
+const IN_BROWSER = typeof window !== 'undefined' 
+const has_local_storage = () => typeof window !== 'undefined' && !!window.localStorage
+const set_cache = (key: string, authToken: string) => has_local_storage() && (window.localStorage[key] = authToken)
+const access_cache = (key=DEFAULT_AUTHTOKEN_KEY) => has_local_storage() ? window.localStorage[key] : undefined
+
 export class Session {
   host: string;
   authToken: string;
+  cacheKey: string;
   apiKey?: string;
   socket?: Socket;
+  handleUnauthenticated?: SessionOptions['handleUnauthenticated']
   socketAuthenticated: boolean;
+  userInfo: { businessId?: string };
+  sessionStart = Date.now();
+  AUTO_REFRESH_MS = 3600000 // 1hr elapsed
 
   config: { headers: { Authorization: string }};
 
-  constructor(o={} as SessionOptions) {
+  constructor(o={} as SessionOptions & RequestOptions) {
     this.host= o.host ?? DEFAULT_HOST
-    this.authToken = o.authToken ?? '';
-    this.config = { headers: { Authorization: generateBearer(o.authToken ?? '') } }
     this.apiKey = o.apiKey ?? '';
     this.socket = undefined as Socket | undefined
     this.socketAuthenticated = false
+    this.handleUnauthenticated = o.handleUnauthenticated
+
+    this.cacheKey = o.cacheKey || DEFAULT_AUTHTOKEN_KEY
+    this.authToken = o.authToken ?? access_cache(o.cacheKey) ?? '';
+    this.userInfo = JSON.parse(access_cache(o.cacheKey + 'userInfo') || '{}');
+    if (this.authToken) { 
+      set_cache(this.cacheKey, this.authToken)
+      this.authenticate_socket()
+    }
+    this.config = { headers: { Authorization: generateBearer(this.authToken ?? '') } } // initialize after authToken
   }
+  
+  resolve_field = async <T>(p: () => Promise<T>, field: keyof T) => (await p())[field]
 
   setAuthToken = (a: string) => { 
     this.authToken = a; 
     this.config.headers.Authorization = generateBearer(a);
+    set_cache(this.cacheKey, a)
   }
-  // setApiKey    = (k: string) => apiKey = k
 
-  getAuthInfo = (requiresAuth?: boolean) => requiresAuth && this.apiKey ? { apiKey: this.apiKey } : { }
+  setUserInfo = (u: { businessId: string }) => { 
+    this.userInfo = u; 
+    set_cache(this.cacheKey + 'userInfo', JSON.stringify(u))
+  }
+  
+  clearCache = () => {
+    set_cache(this.cacheKey, '')
+    set_cache(this.cacheKey + 'userInfo', '')
+  }
+
+  clearState = () => {
+    this.apiKey = ''
+    this.authToken = ''
+    this.userInfo = { }
+    this.clearCache()
+  }
 
+  getAuthInfo = (requiresAuth?: boolean) => requiresAuth && this.apiKey ? { apiKey: this.apiKey } : { }
+  
+  errorHandler = async (_err: any) => {
+    const err = parseError(_err)
+    if (err === 'Unauthenticated') {
+      this.authToken = ''
+      this.clearCache()
+      await this.handleUnauthenticated?.()
+    }
+
+    return err
+  }
   POST = async <A,R=void>(endpoint: string, args?: A, authenticated=true) => {
     try {
       return (await axios.post(
@@ -92,7 +139,7 @@ export class Session {
         { ...args, ...this.getAuthInfo(authenticated) }, 
         this.config)
       ).data as R
-    } catch(err) { throw parseError(err) }
+    } catch(err) { throw await this.errorHandler(err) }
   }
 
   GET = async <A,R=void>(endpoint: string, params?: A, authenticated=true) => {
@@ -102,7 +149,7 @@ export class Session {
         { params: { ...params, ...this.getAuthInfo(authenticated)  }, 
         headers: this.config.headers })
       ).data as R
-    } catch(err) { throw parseError(err) }
+    } catch(err) { throw await this.errorHandler(err) }
   }
 
   PATCH = async <A,R=void>(endpoint: string, params?: A, authenticated=true) => {
@@ -112,7 +159,7 @@ export class Session {
         { ...params, ...this.getAuthInfo(authenticated)  }, 
         this.config)
       ).data as R
-    } catch(err) { throw parseError(err) }
+    } catch(err) { throw await this.errorHandler(err) }
   }
 
   DELETE = async <A,R=void>(endpoint: string, args?: A, authenticated=true) => {
@@ -122,14 +169,55 @@ export class Session {
         { data: { ...args, ...this.getAuthInfo(authenticated)  }, 
         headers: this.config.headers })
       ).data as R
-    } catch(err) { throw parseError(err) }
+    } catch(err) { throw await this.errorHandler(err) }
+  }
+
+  UPLOAD = async (presigned: S3PresignedPost, file?: FileBlob, buffer?: FileBlob) => {
+    const formData = IN_BROWSER ? new FormData() : new NodeFormData();
+    Object.keys(presigned.fields).forEach(key => {
+      formData.append(key, presigned.fields[key]);
+    });
+
+    // has to be appended last 
+    if (!IN_BROWSER) file = buffer || file // use raw buffer if file is Node Blob
+    formData.append("file", file as Blob)
+
+    try {
+      await axios.post(presigned.url, formData,  {
+        headers: IN_BROWSER 
+          ? { 'Content-Type': 'multipart/form-data'} 
+          : { 
+              ...(formData as NodeFormData).getHeaders(), 
+              'Content-Length' : (formData as any).maxDataSize 
+            }
+      })
+    }
+    catch(err) { console.error(err); throw err }
   }
 
-  EMIT = async (route: string, args: object, authenticated=true) => {
+  EMIT = async (route: string, args: object, authenticated=true, options={} as RequestOptions) => {
     this.socket?.emit(route, { ...args, ...authenticated ? { authToken: this.authToken } : {} } )
   }
 
   ON = <T={}>(s: string, callback: (a: T) => void) => this.socket?.on(s, callback)
 
-  authenticate_socket = () => !!this.socket?.emit('authenticate', this.authToken) 
+  subscribe = (rooms: { [index: string]: keyof ClientModelForName }, handlers?: { [index: string]: (a: any) => void } ) => {
+    if (handlers) { this.handle_events(handlers) }
+    this.EMIT('join-rooms', { rooms })
+  }
+
+  handle_events = ( handlers: { [index: string]: (a: any) => void } ) => {
+    for (const handler in handlers) this.ON(handler, handlers[handler])
+  } 
+
+  unsubscribe = (roomIds: string[]) => this.EMIT('leave-rooms', { roomIds })
+  removeAllSocketListeners = (s: string) => this.socket?.removeAllListeners(s)
+
+  authenticate_socket = () => {
+    this.socket = io(`${this.host}/${this.userInfo.businessId}`, { transports: ['websocket'] }); // supporting polling requires sticky session at load balancer
+    this.socket.on('disconnect', () => { this.socketAuthenticated = false })
+    this.socket.on('authenticated', () => { this.socketAuthenticated = true })
+
+    this.socket.emit('authenticate', this.authToken)
+  }
 }

package/src/tests/public_endpoint_tests.ts

@@ -2,9 +2,11 @@ import {
   assert,
   async_test,
   log_header,
-  objects_equivalent,
   wait,
 } from "@tellescope/testing"
+import {
+  objects_equivalent,
+} from "@tellescope/utilities"
 import { Session, /* APIQuery */ } from "../sdk"
 import { PublicEndpoints } from "../public"
 
@@ -30,14 +32,14 @@ const enduser_login_tests = async () => {
   )
   await async_test(
     'setPassword', 
-    () => sdk.api.endusers.setPassword(e.id, password),
+    () => sdk.api.endusers.setPassword({ id: e.id, password }),
     { onResult: _ => true }
   )
 
   let authToken = 'placeholder'
   await async_test(
     'isAuthenticated (no)', 
-    () => sdk.api.endusers.isAuthenticated(e.id, authToken),
+    () => sdk.api.endusers.isAuthenticated({ id: e.id, authToken }),
     { onResult: ({ isAuthenticated, enduser }) => isAuthenticated === false && enduser === null }
   )
   await async_test(
@@ -47,7 +49,7 @@ const enduser_login_tests = async () => {
   )
   await async_test(
     'isAuthenticated (yes)', 
-    () => sdk.api.endusers.isAuthenticated(e.id, authToken),
+    () => sdk.api.endusers.isAuthenticated({ id: e.id, authToken }),
     { onResult: ({ isAuthenticated, enduser }) => isAuthenticated === true && enduser?.id === e.id }
   )
 }

package/src/tests/socket_tests.ts

@@ -1,9 +1,18 @@
 import {
   assert,
+  async_test,
   log_header,
-  objects_equivalent,
   wait,
 } from "@tellescope/testing"
+import {
+  objects_equivalent,
+} from "@tellescope/utilities"
+import {
+  ChatMessage,
+} from "@tellescope/types-client"
+import {
+  Indexable,
+} from "@tellescope/types-utilities"
 import { EnduserSession } from "../enduser"
 import { Session, /* APIQuery */ } from "../sdk"
 
@@ -23,8 +32,7 @@ if (!(email && password && email2 && password2)) {
 const basic_tests = async () => {
   const socket_events: Indexable[] = []
 
-  user2.subscribe({ 'endusers': 'endusers' })
-  user2.handle_events({
+  user2.subscribe({ 'endusers': 'endusers' }, {
     'created-endusers': es => socket_events.push(es),
     'updated-endusers': es => socket_events.push(es),
     'deleted-endusers': es => socket_events.push(es),
@@ -116,11 +124,10 @@ const access_tests = async () => {
 }
 
 const enduser_tests = async () => {
-  const enduser = await user1.api.endusers.createOne({ email: "sockettest@tellescope.com" })
-  await user1.api.endusers.setPassword(enduser.id, 'enduserpassword')
+  const enduser = await user1.api.endusers.createOne({ email: "enduser@tellescope.com" })
+  await user1.api.endusers.setPassword({ id: enduser.id, password: 'enduserPassword!' })
 
-  await enduserSDK.authenticate(enduser.email as string, 'enduserpassword')
-  enduserSDK.authenticate_socket()
+  await enduserSDK.authenticate(enduser.email as string, 'enduserPassword!')
   await wait(undefined, 25)
 
   const userEvents = [] as ChatMessage[]
@@ -140,18 +147,31 @@ const enduser_tests = async () => {
 
   user1.handle_events({
     'created-chats': rs => userEvents.push(...rs),
-    'updated-chats': rs => enduserEvents.push(...rs),
+  }) 
+  enduserSDK.handle_events({
+    'created-chats': rs => enduserEvents.push(...rs),
   }) 
 
   const messageToEnduser = await user1.api.chats.createOne({ roomId: room.id, message: "Hello!" })
   const messageToUser    = await enduserSDK.api.chats.createOne({ roomId: room.id, message: "Hello right back!" })
+  await wait(undefined, 25)
 
-  console.log(userEvents, enduserEvents)
+  assert(objects_equivalent(userEvents[0], messageToUser), 'no message on socket', 'push message to user')
+  assert(objects_equivalent(enduserEvents[0], messageToEnduser), 'no message on socket', 'push message to enduser')
+  
+  // test enduser logout
+  await enduserSDK.api.endusers.logout()
+  await async_test(
+    `verify enduser logout works`, 
+    () => enduserSDK.api.chats.getSome({}), 
+    { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+  )
 
+  // keep these models around for front-end testing
   // cleanup
-  await user1.api.endusers.deleteOne(enduser.id)
-  await user1.api.chats.deleteOne(messageToEnduser.id)
-  await user1.api.chats.deleteOne(messageToUser.id)
+  // await user1.api.endusers.deleteOne(enduser.id) 
+  // await user1.api.chats.deleteOne(messageToEnduser.id)
+  // await user1.api.chats.deleteOne(messageToUser.id)
 }
 
 (async () => {
@@ -160,10 +180,11 @@ const enduser_tests = async () => {
   try {
     await user1.authenticate(email, password, host)
     await user1.reset_db()
-    await user2.authenticate(email2, password2, host) // generate authToken + socket connection for API key
-    
+    await user2.authenticate(email2, password2, host) // generate authToken + socket connection for API keyj
+    await wait(undefined, 25)
+
     let loopCount = 0
-    while (!(user1.socket_is_authenticated() && user2.socket_is_authenticated()) && ++loopCount < 10) {
+    while (!(user1.socketAuthenticated && user2.socketAuthenticated) && ++loopCount < 10) {
       user2.authenticate_socket()
       await wait(undefined, 100)
     }
@@ -171,7 +192,7 @@ const enduser_tests = async () => {
       console.log("Failed to authenticate")
       process.exit()
     }
-
+    
     await enduser_tests()
     await basic_tests()
     await access_tests()