@tellescope/sdk 0.0.7 → 0.0.11

package/src/tests/public_endpoint_tests.ts

@@ -32,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(
@@ -49,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

@@ -7,8 +7,15 @@ import {
 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"
+import { PLACEHOLDER_ID } from "@tellescope/constants"
 
 
 const host = process.env.TEST_URL || 'http://localhost:8080'
@@ -56,14 +63,14 @@ const access_tests = async () => {
   // const user2Deletions: string[] = []
 
   user1.handle_events({
-    'created-chat-rooms': rs => user1Events.push(...rs),
-    'updated-chat-rooms': rs => user1Events.push(...rs),
-    'deleted-chat-rooms': rs => user1Events.push(...rs),
+    'created-chat_rooms': rs => user1Events.push(...rs),
+    // 'updated-chat_rooms': rs => user1Events.push(...rs), sent message will create update event as cached messagepreview/sender updated
+    // 'deleted-chat_rooms': rs => user1Events.push(...rs),
   })
   user2.handle_events({
-    'created-chat-rooms': rs => user2Events.push(...rs),
-    'updated-chat-rooms': rs => user2Events.push(...rs),
-    'deleted-chat-rooms': rs => user2Events.push(...rs),
+    'created-chat_rooms': rs => user2Events.push(...rs),
+    // 'updated-chat_rooms': rs => user2Events.push(...rs),
+    // 'deleted-chat_rooms': rs => user2Events.push(...rs),
   })
 
   const user1Id = user1.userInfo.id
@@ -78,6 +85,13 @@ const access_tests = async () => {
   assert(user1Events.length === 0, 'bad event distribution for filter', 'verify filter socket no self')
   assert(user2Events.length === 1 && sharedRoom.id === user2Events[0].id, 'bad event distribution for filter', 'verify filter socket push')
 
+  user1.removeAllSocketListeners('created-chat_rooms')
+  user1.removeAllSocketListeners('update-chat_rooms')
+  user1.removeAllSocketListeners('deleted-chat_rooms')
+  user2.removeAllSocketListeners('created-chat_rooms')
+  user2.removeAllSocketListeners('update-chat_rooms')
+  user2.removeAllSocketListeners('deleted-chat_rooms')
+
   user1.subscribe({ [room.id]: 'chats' })
   await wait(undefined, 10)
   user2.subscribe({ [room.id]: 'chats' }) // connection should be rejected
@@ -109,7 +123,7 @@ const access_tests = async () => {
   await wait(undefined, 25)
   const sharedChat2 = await user2.api.chats.createOne({ roomId: sharedRoom.id, message: "Hello there!", })
   await wait(undefined, 25)
-
+  
   assert(user1Events.length === 1 && user1Events[0].id === sharedChat2.id, 'bad chats subscription', 'verify chat received')
   assert(
     user2Events.length === 2 && user2Events[1].id === sharedChat.id, 
@@ -119,7 +133,7 @@ const access_tests = async () => {
 
 const enduser_tests = async () => {
   const enduser = await user1.api.endusers.createOne({ email: "enduser@tellescope.com" })
-  await user1.api.endusers.setPassword(enduser.id, 'enduserPassword!')
+  await user1.api.endusers.setPassword({ id: enduser.id, password: 'enduserPassword!' })
 
   await enduserSDK.authenticate(enduser.email as string, 'enduserPassword!')
   await wait(undefined, 25)
@@ -135,15 +149,18 @@ const enduser_tests = async () => {
   await wait(undefined, 25)
 
   user1.subscribe({ [room.id]: 'chats' })
+  user1.subscribe({ tickets: 'tickets' })
   await wait(undefined, 10)
   enduserSDK.subscribe({ [room.id]: 'chats' }) 
   await wait(undefined, 10)
 
   user1.handle_events({
     'created-chats': rs => userEvents.push(...rs),
+    'created-tickets': rs => userEvents.push(...rs),
   }) 
   enduserSDK.handle_events({
     'created-chats': rs => enduserEvents.push(...rs),
+    'created-tickets': rs => enduserEvents.push(...rs),
   }) 
 
   const messageToEnduser = await user1.api.chats.createOne({ roomId: room.id, message: "Hello!" })
@@ -152,7 +169,20 @@ const enduser_tests = async () => {
 
   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')
+
+  const unusedTicket = await user1.api.tickets.createOne({ enduserId: PLACEHOLDER_ID, title: "For Noone" }) // should not get pushed to enduser
+  const ticketForEnduser  = await user1.api.tickets.createOne({ enduserId: enduser.id, title: "For enduser" })
+  const ticketFromEnduser = await enduserSDK.api.tickets.createOne({ enduserId: enduser.id, title: "By enduser" })
+  await wait(undefined, 25)
+
+  assert(objects_equivalent(userEvents[1], ticketFromEnduser), 'no ticket on socket for user', 'push ticket to user')
+  assert(objects_equivalent(enduserEvents[1], ticketForEnduser), 'no ticket on socket for enduser', 'push ticket to enduser')
+  assert(enduserEvents[2] === undefined, 'enduser got an orgwide ticket', 'enduser does not receive org-wide ticket')
   
+  await user1.api.tickets.deleteOne(unusedTicket.id)
+  await user1.api.tickets.deleteOne(ticketForEnduser.id)
+  await user1.api.tickets.deleteOne(ticketFromEnduser.id)
+
   // test enduser logout
   await enduserSDK.api.endusers.logout()
   await async_test(

package/src/tests/tests.ts

@@ -6,24 +6,30 @@ import {
   ClientModelForName,
   ClientModelForName_required,
 } from "@tellescope/types-client"
+import { 
+  Model as ClientModel,
+  ModelName,
+} from "@tellescope/types-models"
 
-
-// import v from 'validator'
+import {
+  Indexable,
+  Operation,
+} from "@tellescope/types-utilities"
 
 import {
   fieldsToValidation,
   mongoIdValidator,
 
-  // InputValidation,
+  InputValidation,
 } from "@tellescope/validation"
 
 import { Session, APIQuery, EnduserSession } from "../sdk"
-import { url_safe_path } from "@tellescope/utilities"
-import { DEFAULT_OPERATIONS } from "@tellescope/constants"
+import {  } from "@tellescope/utilities"
+import { DEFAULT_OPERATIONS, PLACEHOLDER_ID } from "@tellescope/constants"
 import { 
   schema, 
-  // Model, 
-  // ModelFields 
+  Model, 
+  ModelFields,
 } from "@tellescope/schema"
 
 import {
@@ -35,6 +41,7 @@ import {
 
 import {
   objects_equivalent,
+  url_safe_path,
 } from "@tellescope/utilities"
 
 
@@ -183,6 +190,48 @@ const threadKeyTests = async () => {
   ])
 }
 
+const filterTests = async () => {
+  const enduser = await sdk.api.endusers.createOne({ email: 'filtertests@tellescope.com', fname: 'test' })
+  const otherEnduser = await sdk.api.endusers.createOne({ email: 'other@tellescope.com' })
+  await async_test(
+    `find enduser by filter`, 
+    () => sdk.api.endusers.getSome({ filter: { email: 'filtertests@tellescope.com' }}), 
+    { onResult: es => es.length === 1 && es[0].id === enduser.id },
+  )
+  await async_test(
+    `find enduser by compound filter`, 
+    () => sdk.api.endusers.getSome({ filter: { email: 'filtertests@tellescope.com', fname: 'test' }}), 
+    { onResult: es => es.length === 1 && es[0].id === enduser.id },
+  )
+  await async_test(
+    `nothing found by invalid compound filter`, 
+    () => sdk.api.endusers.getSome({ filter: { email: 'filtertests@tellescope.com', fname: 'nottest' }}), 
+    { onResult: es => es.length === 0 },
+  )
+  await async_test(
+    `nothing found for invalid filter`, 
+    () => sdk.api.endusers.getSome({ filter: { email: 'doesnotexist@tellescope.com' }}), 
+    { onResult: es => es.length === 0 },
+  )
+
+  await sdk.api.endusers.deleteOne(enduser.id)
+  await sdk.api.endusers.deleteOne(otherEnduser.id)
+}
+
+const updatesTests = async () => {
+  const enduser = await sdk.api.endusers.createOne({ email: 'test@tellescope.com', phone: '+15555555555' })
+  await sdk.api.endusers.updateOne(enduser.id, { phone: '+15555555552' }) // update to new phone number 
+  await sdk.api.endusers.updateOne(enduser.id, { phone: '+15555555552' }) // update to same phone number
+  assert(!!enduser, '', 'Updated phone number')
+
+  const task = await sdk.api.tasks.createOne({ text: "do the thing", completed: false })
+  await sdk.api.tasks.updateOne(task.id, { completed: false }) // test setting false (falsey value) on update
+  assert(!!task, '', 'Set completed false')
+
+  await sdk.api.tasks.deleteOne(task.id)
+  await sdk.api.endusers.deleteOne(enduser.id)
+}
+
 const instanceForModel = <N extends ModelName, T=ClientModelForName[N], REQ=ClientModelForName_required[N]>(model: Model<T, N>, i=0) => {
   const instance = {} as Indexable
   const updates = {} as Indexable
@@ -304,7 +353,7 @@ const run_generated_tests = async <N extends ModelName>({ queries, model, name,
     await async_test(
       `update-${singularName}`, 
       () => queries.updateOne(_id, updates, { replaceObjectFields: true }), 
-      passOnVoid
+      { onResult: u => typeof u === 'object' && u.id === _id }
     )
   }
   await async_test(
@@ -550,7 +599,7 @@ const journey_tests = async (queries=sdk.api.journeys) => {
 
   await async_test(
     `journey-updateState`, 
-    () => queries.updateState(journey.id, 'Added', { name: 'Updated', priority: 'N/A' }), 
+    () => queries.updateState({ id: journey.id, name: 'Added', updates: { name: 'Updated', priority: 'N/A' }}),
     passOnVoid,
   )
   await wait(undefined, 25) // wait for side effects to update endusers
@@ -813,7 +862,7 @@ const enduserAccessTests = async () => {
   const password = 'testpassword'
 
   const enduser = await sdk.api.endusers.createOne({ email })
-  await sdk.api.endusers.setPassword(enduser.id, password).catch(console.error)
+  await sdk.api.endusers.setPassword({ id: enduser.id, password }).catch(console.error)
   await enduserSDK.authenticate(email, password).catch(console.error)
 
   for (const n in schema) {
@@ -864,6 +913,31 @@ const enduserAccessTests = async () => {
     } 
   }
 
+  const ticketAccessible = await sdk.api.tickets.createOne({ enduserId: enduser.id, title: "Accessible ticket" })
+  const ticketInaccessible = await sdk.api.tickets.createOne({ enduserId: PLACEHOLDER_ID, title: "Inaccessible ticket" })
+  await async_test(
+    `enduser cannot create ticket for another enduser`,
+    () => enduserSDK.api.tickets.createOne({ enduserId: sdk.userInfo.id, title: "Error on Creation" }),
+    { shouldError: true, onError: e => e.message === "enduserId does not match creator id for enduser session" }
+  )
+  await async_test(
+    `enduser-access default, no access constraints, matching enduserId`,
+    () => enduserSDK.api.tickets.getOne(ticketAccessible.id),
+    { onResult: t => t.id === ticketAccessible.id }
+  )
+  await async_test(
+    `no-enduser-access default, no access constraints, non-matching enduserId`,
+    () => enduserSDK.api.tickets.getOne(ticketInaccessible.id),
+    { shouldError: true, onError: e => e.message.startsWith("Could not find")}
+  )
+  await async_test(
+    `no-enduser-access default, no access constraints, get many`,
+    () => enduserSDK.api.tickets.getSome(),
+    { onResult: ts => ts.length === 1 }
+  )
+
+  await sdk.api.tickets.deleteOne(ticketAccessible.id)
+  await sdk.api.tickets.deleteOne(ticketInaccessible.id)
   await sdk.api.endusers.deleteOne(enduser.id)
 }
 
@@ -879,16 +953,29 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
   chat_rooms: chat_room_tests,
   users: () => {},
   templates: () => {},
+  files: () => {},
+  tickets: () => {},
+  meetings: () => {},
 };
 
 (async () => {
   await sdk.authenticate(email, password, host)
 
   log_header("API")
-  await setup_tests()
-  await enduserAccessTests()
-  await multi_tenant_tests() // should come right after setup tests
-  await threadKeyTests()
+  
+  try {
+    await setup_tests()
+    await multi_tenant_tests() // should come right after setup tests
+    await filterTests()
+    await updatesTests()
+    await threadKeyTests()
+    await enduserAccessTests()
+  } catch(err) {
+    console.error("Failed during custom test")
+    console.error(err)
+    process.exit()
+  }
+
 
   let n: keyof typeof schema;
   for (n in schema) {

package/tsconfig.json

@@ -10,7 +10,6 @@
     { "path": "../constants" },
     { "path": "../schema" },
     { "path": "../testing" },
-    { "path": "../types" },
     { "path": "../types-client" },
     { "path": "../utilities" },
     { "path": "../validation" }