@tellescope/sdk 0.0.19 → 0.0.23

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@tellescope/sdk",
-  "version": "0.0.19",
+  "version": "0.0.23",
   "description": "Code for interacting with the Tellescope API",
   "main": "./lib/cjs/sdk.js",
   "module": "./lib/esm/sdk.js",
   "types": "./lib/esm/sdk.d.ts",
   "scripts": {
     "test": "npm run-script build:cjs && npm run-script retest",
-    "retest": "npm run-script retest-sockets && npm run-script retest-api && npm run-script retest-public-api",
+    "retest": "npm run-script retest-api && npm run-script retest-public-api && npm run-script retest-webhooks && npm run-script retest-sockets",
     "test-api": "npm run-script build:cjs && npm run-script retest-api",
     "retest-api": "node lib/cjs/tests/tests.js",
     "test-public-api": "npm run-script build:cjs && npm run-script retest-public-api",
     "retest-public-api": "node lib/cjs/tests/public_endpoint_tests.js",
     "test-sockets": "npm run-script build:cjs && npm run-script retest-sockets",
     "retest-sockets": "node lib/cjs/tests/socket_tests.js",
+    "test-webhooks": "npm run-script build:cjs && npm run-script retest-webhooks",
+    "retest-webhooks": "node lib/cjs/tests/webhooks_tests.js",
     "build": "npm run-script build:esm && npm run-script build:cjs",
     "build:esm": "tsc",
     "build:cjs": "tsc --module commonjs --outDir lib/cjs",
@@ -30,15 +32,16 @@
   },
   "homepage": "https://github.com/tellescope-os/tellescope#readme",
   "dependencies": {
-    "@tellescope/constants": "^0.0.19",
-    "@tellescope/schema": "^0.0.19",
-    "@tellescope/testing": "^0.0.19",
-    "@tellescope/types-client": "^0.0.19",
-    "@tellescope/types-models": "^0.0.19",
-    "@tellescope/types-utilities": "^0.0.19",
-    "@tellescope/utilities": "^0.0.19",
-    "@tellescope/validation": "^0.0.19",
+    "@tellescope/constants": "^0.0.23",
+    "@tellescope/schema": "^0.0.23",
+    "@tellescope/testing": "^0.0.23",
+    "@tellescope/types-client": "^0.0.23",
+    "@tellescope/types-models": "^0.0.23",
+    "@tellescope/types-utilities": "^0.0.23",
+    "@tellescope/utilities": "^0.0.23",
+    "@tellescope/validation": "^0.0.23",
     "axios": "^0.21.1",
+    "express": "^4.17.1",
     "form-data": "^4.0.0",
     "socket.io-client": "^4.2.0",
     "source-map-support": "^0.5.20"
@@ -53,5 +56,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ddee8ca945d3daf7355a9eada1305666e56d7434"
+  "gitHead": "da81cccdf2fcf06080a5a7d33e0a1cdac9f05a40"
 }

package/src/enduser.ts

@@ -6,14 +6,16 @@ import { url_safe_path } from "@tellescope/utilities"
 
 import { S3PresignedPost, UserIdentity } from "@tellescope/types-utilities"
 import { 
+  Attendee,
   AttendeeInfo, 
-  Meeting,
 } from "@tellescope/types-models"
 import {
   ClientModelForName,
   ClientModelForName_required,
   Enduser,
   File,
+  Meeting,
+  UserDisplayInfo,
 } from "@tellescope/types-client"
 
 export interface EnduserSessionOptions extends SessionOptions {}
@@ -43,14 +45,14 @@ type EnduserQueries = { [K in EnduserAccessibleModels]: APIQuery<K> } & {
     logout: () => Promise<void>;
   },
   users: {
-    display_info: () => Promise<{ fname?: string, lname?: string, id: string, lastActive?: Date, lastLogout?: Date }[]>
+    display_info: () => Promise<UserDisplayInfo[]>
   },
   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 }>,
   },
   meetings: {
-    attendee_info: (args: { id: string }) => Promise<{ attendee: AttendeeInfo, others: UserIdentity[] }>,
+    attendee_info: (args: { id: string }) => Promise<{ attendee: Attendee, others: UserIdentity[] }>,
     my_meetings: () => Promise<Meeting[]>,
   },
 }
@@ -68,8 +70,9 @@ export class EnduserSession extends Session {
   userInfo!: Enduser; 
   api: EnduserQueries;
 
-  constructor(o?: EnduserSessionOptions) {
+  constructor(o?: EnduserSessionOptions & { enduser?: Enduser }) {
     super({ ...o, cacheKey: o?.cacheKey || "tellescope_enduser" })
+    if (o?.enduser) this.userInfo = o.enduser
     
     this.api = loadDefaultQueries(this) as EnduserQueries 
 
@@ -77,7 +80,7 @@ export class EnduserSession extends Session {
       logout: () => this._POST('/v1/logout-enduser'),
     }
     this.api.users = { 
-      display_info: () => this._GET<{}, { fname: string, lname: string, id: string }[] >(`/v1/user-display-info`),
+      display_info: () => this._GET<{}, UserDisplayInfo[] >(`/v1/user-display-info`),
     }
     this.api.meetings = { 
       attendee_info: a => this._GET('/v1/attendee-info', a),

package/src/sdk.ts

@@ -1,10 +1,11 @@
 import {
   AttendeeInfo,
   JourneyState, 
-  Meeting,
   UserSession,
   MeetingInfo,
   ReadFilter,
+  WebhookSubscriptionsType,
+  Attendee,
 } from "@tellescope/types-models"
 
 import {
@@ -15,6 +16,7 @@ import {
   ChatRoom,
   Enduser,
   File,
+  Meeting,
 } from "@tellescope/types-client"
 import { CustomUpdateOptions, SortOption, S3PresignedPost, UserIdentity } from "@tellescope/types-utilities"
 import { url_safe_path } from "@tellescope/utilities"
@@ -82,6 +84,7 @@ const loadDefaultQueries = (s: Session): { [K in keyof ClientModelForName] : API
   tickets: defaultQueries(s, 'tickets'),
   meetings: defaultQueries(s, 'meetings'),
   notes: defaultQueries(s, 'notes'),
+  webhooks: defaultQueries(s, 'webhooks')
 })
 
 type Queries = { [K in keyof ClientModelForName]: APIQuery<K> } & {
@@ -101,23 +104,29 @@ type Queries = { [K in keyof ClientModelForName]: APIQuery<K> } & {
     file_download_URL: (args: { secureName: string }) => Promise<{ downloadURL: string }>,
   },
   meetings: {
-    start_meeting: () => Promise<{ id: string, meeting: { Meeting: MeetingInfo }, host: { Attendee: AttendeeInfo } }>, 
+    start_meeting: () => Promise<{ id: string, meeting: { Meeting: MeetingInfo }, host: Attendee }>, 
     end_meeting: (args: { id: string }) => Promise<void>, 
     add_attendees_to_meeting: (args: { id: string, attendees: UserIdentity[] }) => Promise<void>, 
     my_meetings: () => Promise<Meeting[]>,
-    attendee_info: (args: { id: string }) => Promise<{ attendee: AttendeeInfo, others: UserIdentity[] }>,
+    attendee_info: (args: { id: string }) => Promise<{ attendee: Attendee, others: UserIdentity[] }>,
   },
   chat_rooms: {
     join_room: (args: { id: string }) => Promise<{ room: ChatRoom }>,
   },
+  webhooks: {
+    configure: (args: { url: string, secret: string, subscriptions?: WebhookSubscriptionsType }) => Promise<void>,
+    update: (args: { url?: string, secret?: string, subscriptionUpdates?: WebhookSubscriptionsType }) => Promise<void>
+  },
 }
 
 export class Session extends SessionManager {
   api: Queries;
   userInfo!: UserSession;
 
-  constructor(o?: SessionOptions) {
+  constructor(o?: SessionOptions & { userInfo?: UserSession }) {
     super({ ...o, cacheKey: o?.cacheKey || "tellescope_user" })
+    if (o?.userInfo) this.userInfo = o.userInfo
+
     const queries = loadDefaultQueries(this) as Queries
 
     queries.journeys.update_state = ({id, name, updates}) => this._PATCH(`/v1/journey/${id}/state/${name}`, { updates })
@@ -135,6 +144,9 @@ export class Session extends SessionManager {
     queries.meetings.attendee_info = a => this._GET('/v1/attendee-info', a)
     queries.meetings.my_meetings = () => this._GET('/v1/my-meetings')
 
+    queries.webhooks.configure = a => this._POST('/v1/configure-webhooks', a)
+    queries.webhooks.update = a => this._PATCH('/v1/update-webhooks', a)
+
     this.api = queries
 
     // if (this.userInfo) this.refresh_session()

package/src/session.ts

@@ -3,16 +3,11 @@ 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'

package/src/tests/tests.ts

@@ -288,13 +288,21 @@ const updatesTests = async () => {
 
 const generateEnduserAuthTests = async () => {
   log_header("Generated Enduser authToken Tests")
-  const e = await sdk.api.endusers.createOne({ email: 'generated@tellescope.com', phone: '+15555555555', externalId: '1029f9v9sjd0as' })
+  const externalId = '1029f9v9sjd0as'
+  const e = await sdk.api.endusers.createOne({ email: 'generated@tellescope.com', phone: '+15555555555', externalId })
+
   const { authToken, enduser } = await sdk.api.endusers.generate_auth_token({ id: e.id })
   assert(!!authToken && !!enduser, 'invalid returned values', 'Generate authToken and get enduser')
-
   const { isAuthenticated } = await sdk.api.endusers.is_authenticated({ id: enduser.id, authToken })
   assert(isAuthenticated, 'invalid authToken generated for enduser', 'Generate authToken for enduser is valid')
 
+  const { authToken: authTokenUID, enduser: enduser2 } = await sdk.api.endusers.generate_auth_token({ externalId })
+  assert(!!authTokenUID && !!enduser2, 'invalid returned values eid', 'Generate authToken and get enduser eid')
+  assert((
+    await sdk.api.endusers.is_authenticated({ id: enduser2.id, authToken: authTokenUID })).isAuthenticated, 
+    'invalid authToken generated for enduser', 'Generate authToken for enduser is valid'
+  )
+
   await async_test(
     `auth by externalId`, () => sdk.api.endusers.generate_auth_token({ externalId: e.externalId }), passOnVoid,
   ) 
@@ -965,47 +973,48 @@ const enduserAccessTests = async () => {
   for (const n in schema) {
     const endpoint = url_safe_path(n)
     const model = schema[n as keyof typeof schema]
+    if (n === 'webhooks') continue // no default endpoints implemented
 
     if (!model?.enduserActions?.read && (model.defaultActions.read || model.customActions.read)) {
       await async_test(
         `no-enduser-access getOne (${endpoint})`,
         () => enduserSDK.GET(`/v1/${endpoint.substring(0, endpoint.length - 1)}/:id`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.readMany && (model.defaultActions.readMany || model.customActions.readMany)) {
       await async_test(
         `no-enduser-access getSome (${endpoint})`,
         () => enduserSDK.GET(`/v1/${endpoint}`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.create && (model.defaultActions.create || model.customActions.create)) {
       await async_test(
         `no-enduser-access createOne (${endpoint})`,
         () => enduserSDK.POST(`/v1/${endpoint.substring(0, endpoint.length - 1)}`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.createMany && (model.defaultActions.createMany || model.customActions.createMany)) {
       await async_test(
         `no-enduser-access createMany (${endpoint})`,
         () => enduserSDK.POST(`/v1/${endpoint}`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.update && (model.defaultActions.update || model.customActions.update)) {
       await async_test(
         `no-enduser-access update (${endpoint})`,
         () => enduserSDK.PATCH(`/v1/${endpoint.substring(0, endpoint.length - 1)}/:id`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.delete && (model.defaultActions.delete || model.customActions.delete)) {
       await async_test(
         `no-enduser-access delete (${endpoint})`,
         () => enduserSDK.DELETE(`/v1/${endpoint.substring(0, endpoint.length - 1)}/:id`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
   }
@@ -1052,6 +1061,20 @@ const files_tests = async () => {
   assert(downloaded === buff.toString(), 'downloaded file does not match uploaded file', 'upload, download comparison') 
 }
 
+const enduser_session_tests = async () => {
+  const email = 'enduser@tellescope.com'
+  const password = 'testpassword'
+
+  const enduser = await sdk.api.endusers.createOne({ email })
+  await sdk.api.endusers.set_password({ id: enduser.id, password }).catch(console.error)
+  await enduserSDK.authenticate(email, password).catch(console.error)
+
+  const users = await enduserSDK.api.users.display_info()
+  assert(users && users.length > 0, 'No users returned', 'Get user display info for enduser')
+
+  await sdk.api.endusers.deleteOne(enduser.id)
+}
+
 const tests: { [K in keyof ClientModelForName]: () => void } = {
   chats: chat_tests,
   endusers: enduser_tests,
@@ -1068,6 +1091,7 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
   tickets: () => {},
   meetings: () => {},
   notes: () => {},
+  webhooks: () => {},
 };
 
 (async () => {
@@ -1083,6 +1107,7 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
     await threadKeyTests()
     await enduserAccessTests()
     await generateEnduserAuthTests()
+    await enduser_session_tests()
   } catch(err) {
     console.error("Failed during custom test")
     console.error(err)
@@ -1099,7 +1124,7 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
       model: schema[n] as any, 
       name: n,
       returns: {
-        create: returnValidation as ModelFields<ClientModel>,
+        create: returnValidation as any// ModelFields<ClientModel>,
       }
     })
   }

package/src/tests/webhooks_tests.ts

@@ -0,0 +1,193 @@
+import express from "express"
+import bodyParser from 'body-parser'
+import crypto from "crypto"
+
+import {
+  assert,
+  async_test,
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import {
+  objects_equivalent
+} from "@tellescope/utilities"
+
+import {
+  WEBHOOK_MODELS,
+  WebhookSupportedModel,
+  WebhookRecord,
+  WebhookCall,
+  CUDSubscription,
+} from "@tellescope/types-models"
+
+import { Session } from "../sdk"
+
+const [email, password] = [process.env.TEST_EMAIL, process.env.TEST_PASSWORD]
+const [email2, password2] = [process.env.TEST_EMAIL_2, process.env.TEST_PASSWORD_2]
+const [nonAdminEmail, nonAdminPassword] = [process.env.NON_ADMIN_EMAIL, process.env.NON_ADMIN_PASSWORD]
+if (!(email && password && email2 && password2 && nonAdminEmail && nonAdminPassword)) {
+  console.error("Set TEST_EMAIL and TEST_PASSWORD")
+  process.exit()
+}
+
+
+const sdk = new Session({ host: 'http://localhost:8080' })
+const nonAdminSdk = new Session({ host: 'http://localhost:8080' })
+
+const app = express()
+app.use(bodyParser.urlencoded({ extended: true, limit: '25mb' }))
+app.use(bodyParser.json({ limit: "25mb" }))
+
+const PORT = 4000
+const TEST_SECRET = "this is a test secret for verifying integrity of web hooks"
+const webhookEndpoint = '/handle-webhook'
+const webhookURL = `http://127.0.0.1:${PORT}${webhookEndpoint}`
+
+const sha256 = (s: string) => crypto.createHash('sha256').update(s).digest('hex')
+
+const verify_integrity = (records: WebhookRecord[], timestamp: string, integrity: string,) => (
+  sha256(records.map(r => r.id).join('') + timestamp + TEST_SECRET) === integrity
+)
+
+const handledEvents: WebhookCall[] = []
+app.post(webhookEndpoint, (req, res) => {
+  const body = req.body as WebhookCall
+  // console.log('got hook', body.records, body.timestamp, body.integrity)
+
+  if (!verify_integrity(body.records, body.timestamp, body.integrity)) {
+    console.error("Integrity check failed for request", JSON.stringify(body, null, 2))
+    process.exit()
+  }
+
+  handledEvents.push(req.body)
+  res.status(204).end()
+})
+
+const fullSubscription = {} as { [K in WebhookSupportedModel]: CUDSubscription }
+const emptySubscription = {} as { [K in WebhookSupportedModel]: CUDSubscription }
+for (const model in WEBHOOK_MODELS) {
+  fullSubscription[model as WebhookSupportedModel] = { create: true, update: true, delete: true }
+  emptySubscription[model as WebhookSupportedModel] = { create: false, update: false, delete: false }
+}
+
+let webhookIndex = 0
+const check_next_webhook = async (evaluate: (hook: WebhookCall) => boolean, name: string, error: string, isSubscribed: boolean) => {
+  if (isSubscribed === false) return
+
+  await wait(undefined, 25) // wait for hook to post
+
+  const event = handledEvents[webhookIndex]
+  assert(!!event, 'did not get hook', 'got hook')
+  if (!event) return // ensure webhookIndex not incremented
+
+  const success = evaluate(event)
+  assert(success, error, name)
+  if (!success) { console.error('Got', event) }
+
+  webhookIndex++
+}
+
+const chats_tests = async (isSubscribed: boolean) => {
+  log_header(`Chats Tests, isSubscribed=${isSubscribed}`)
+  const room = await sdk.api.chat_rooms.createOne({ userIds: [sdk.userInfo.id] })
+
+  const chat = await sdk.api.chats.createOne({ roomId: room.id, message: "Hello hello hi hello" })
+  await check_next_webhook(a => objects_equivalent(a.records, [chat]), 'Create chat error', 'Create chat webhook', isSubscribed)
+
+  // cleanup
+  await sdk.api.chat_rooms.deleteOne(room.id) // also cleans up messages
+
+  // when chatroom support added for webhooks, check deletion here
+  // await check_next_webhook(a => objects_equivalent(a.records, [chat_room]), 'Delete chat room error', 'Delete chat room webhook', isSubscribed)
+}
+
+const meetings_tests = async (isSubscribed: boolean) => {
+  log_header(`Meetings Tests, isSubscribed=${isSubscribed}`)
+  const meeting = await sdk.api.meetings.start_meeting()
+
+  await check_next_webhook(a => objects_equivalent(a.records, [meeting]), 'Create meeting error', 'Create meeting webhook', isSubscribed)
+
+  // cleanup
+  await sdk.api.meetings.end_meeting({ id: meeting.id }) // also cleans up messages
+}
+
+const tests: { [K in WebhookSupportedModel]: (isSubscribed: boolean) => Promise<void> } = {
+  chats: chats_tests,
+  meetings: meetings_tests,
+}
+
+const run_tests = async () => {
+  log_header("Webhooks Tests")
+  await sdk.authenticate(email, password)
+  await sdk.reset_db() 
+  await nonAdminSdk.authenticate(nonAdminEmail, nonAdminPassword)
+
+  await async_test(
+    'configure webhook is admin only',
+    () => nonAdminSdk.api.webhooks.configure({ url: webhookURL, secret: TEST_SECRET }),
+    { shouldError: true, onError: e => e.message === "Inaccessible" || e.message === "Admin access only"}
+  )
+  await async_test(
+    'update webhook is admin only',
+    () => nonAdminSdk.api.webhooks.update({ subscriptionUpdates: fullSubscription }),
+    { shouldError: true, onError: e => e.message === "Inaccessible" || e.message === "Admin access only"}
+  )
+
+  await async_test(
+    'configure webhook',
+    () => sdk.api.webhooks.configure({ url: webhookURL, secret: TEST_SECRET }),
+    { onResult: _ => true }
+  )
+  await async_test(
+    'configure webhook (only callable once)',
+    () => sdk.api.webhooks.configure({ url: webhookURL, secret: TEST_SECRET }),
+    { shouldError: true, onError: e => e.message === "Only one webhook configuration is supported per organization. Use /update-webooks to update your configuration." }
+  )
+  await async_test(
+    'update webhook (set empty subscription)',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: {} }),
+    { onResult: _ => true }
+  )
+  await async_test(
+    'update webhook (set partial subscription)',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: { chats: { create: true }} }),
+    { onResult: _ => true }
+  )
+  await async_test(
+    'update webhook (set subscriptions)',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: fullSubscription }),
+    { onResult: _ => true }
+  )
+  await async_test(
+    'update webhook invalid model',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: { notAModel: { create: false } } as any }),
+    { shouldError: true, onError: e => e.message === "Error parsing field subscriptionUpdates: Got unexpected field(s) [notAModel]" }
+  )
+
+  log_header("Webhooks Tests with Subscriptions")
+  for (const t in tests) {
+    await tests[t as keyof typeof tests](true)
+  }
+  const finalLength = handledEvents.length
+
+  await async_test(
+    'update webhook (set subscriptions empty)',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: emptySubscription }),
+    { onResult: _ => true }
+  )
+
+  log_header("Webhooks Tests without Subscriptions")
+  for (const t in tests) {
+    await tests[t as keyof typeof tests](false)
+  }
+  assert(finalLength === handledEvents.length, 'length changed after subscriptions', 'No webhooks posted when no subscription')
+
+}
+
+app.listen(PORT, async () => {
+  try { 
+    await run_tests()
+  } catch(err) { console.error(err) }
+
+  process.exit()
+})