@tellescope/sdk 0.0.5 → 0.0.9

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()

package/src/tests/tests.ts

@@ -6,34 +6,44 @@ 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 } from "../sdk"
-import { url_safe_path } from "@tellescope/utilities"
+import { Session, APIQuery, EnduserSession } from "../sdk"
+import {  } from "@tellescope/utilities"
 import { DEFAULT_OPERATIONS } from "@tellescope/constants"
 import { 
   schema, 
-  // Model, 
-  // ModelFields 
+  Model, 
+  ModelFields,
 } from "@tellescope/schema"
 
 import {
   assert,
   async_test,
   log_header,
-  objects_equivalent,
   wait,
 } from "@tellescope/testing"
 
+import {
+  objects_equivalent,
+  url_safe_path,
+} from "@tellescope/utilities"
+
 
 const host = process.env.TEST_URL || 'http://localhost:8080'
 const [email, password] = [process.env.TEST_EMAIL, process.env.TEST_PASSWORD]
@@ -41,8 +51,28 @@ const [email2, password2] = [process.env.TEST_EMAIL_2, process.env.TEST_PASSWORD
 
 const userId = '60398b0231a295e64f084fd9'
 
+// const example_SDK_usage = async () => {
+//   // initialize SDK and authenticate a user
+//   const sdk = new Session()
+//   await sdk.authenticate("user-email", 'user-password')
+
+//   // create a record, using Enduser model as example
+//   const enduser = await sdk.api.endusers.createOne({ email: "enduser1@tellescope.com" })
+
+//   // update an existing record
+//   await sdk.api.endusers.updateOne(enduser.id, { phone: "+15555555555" })
+
+//   // fetch a record by id, or a list of recent records
+//   const existingEnduser: Enduser = await sdk.api.endusers.getOne(enduser.id)  
+//   const existingEndusers: Enduser[] = await sdk.api.endusers.getSome({ limit: 5, lastId: enduser.id })  
+
+//   // delete an individual record
+//   await sdk.api.endusers.deleteOne(enduser.id)
+// }
+
 const sdk = new Session()
 const sdkOther = new Session({ host, apiKey: "ba745e25162bb95a795c5fa1af70df188d93c4d3aac9c48b34a5c8c9dd7b80f7" })
+const enduserSDK = new EnduserSession({ host })
 // const sdkOtherEmail = "sebass@tellescope.com"
 
 if (!(email && password && email2 && password2)) {
@@ -160,6 +190,34 @@ 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 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
@@ -281,7 +339,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(
@@ -299,7 +357,7 @@ const run_generated_tests = async <N extends ModelName>({ queries, model, name,
   )
   await async_test(
     `get-${safeName}`, 
-    () => queries.getSome({}, filter), 
+    () => queries.getSome({ filter }), 
     { onResult: ([d, /*...others */]) => {
         // if (others.length !== 0) return false // some collections are not reset during testing, like API keys
         if (!d?.id) return false
@@ -527,7 +585,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
@@ -701,7 +759,7 @@ const chat_tests = async() => {
   )
   await async_test(
     `get-chats (with filter)`, 
-    () => sdk.api.chats.getSome({}, { roomId: room.id }), 
+    () => sdk.api.chats.getSome({ filter: { roomId: room.id } }), 
     { onResult: c => c?.length === 2 }
   )
 
@@ -712,25 +770,27 @@ const chat_tests = async() => {
   )
   await async_test(
     `get-chats not allowed`, 
-    () => sdk2.api.chats.getSome({}, { roomId: room.id }), 
-    { shouldError: true, onError: e => e.message === 'You do not have permission to access this resource' }
-  )
-  await async_test(
-    `update-chat not allowed`, 
-    () => sdk2.api.chats.updateOne(chat.id, { message: 'Hi' }), 
+    () => sdk2.api.chats.getSome({ filter: { roomId: room.id } }), 
     { shouldError: true, onError: e => e.message === 'You do not have permission to access this resource' }
   )
+  // currently disabled endpoint altogether
+  // await async_test(
+  //   `update-chat not allowed`, 
+  //   () => sdk2.api.chats.updateOne(chat.id, { message: 'Hi' }), 
+  //   { shouldError: true, onError: e => e.message === 'You do not have permission to access this resource' }
+  // )
   await async_test(
     `delete-chat not allowed`, 
     () => sdk2.api.chats.deleteOne(chat.id), 
     { shouldError: true, onError: e => e.message === 'You do not have permission to access this resource' }
   )
 
-  await async_test(
-    `update-chat can't update roomId`, 
-    () => sdk.api.chats.updateOne(chat.id, { roomId: room.id } as any), // cast to any to allow calling with bad argument, but typing should catch this too
-    { shouldError: true, onError: e => e.message === 'Error parsing field updates: roomId is not valid for updates' }
-  )
+  // currently disabled endpoint altogether
+  // await async_test(
+  //   `update-chat can't update roomId`, 
+  //   () => sdk.api.chats.updateOne(chat.id, { roomId: room.id } as any), // cast to any to allow calling with bad argument, but typing should catch this too
+  //   { shouldError: true, onError: e => e.message === 'Error parsing field updates: roomId is not valid for updates' }
+  // )
 
   await sdk.api.chat_rooms.deleteOne(room.id)
   await wait(undefined, 25)
@@ -760,12 +820,12 @@ const chat_tests = async() => {
   )
   await async_test(
     `get-chats (shared, user1)`,
-    () => sdk.api.chats.getSome({}, { roomId: sharedRoom.id }), 
+    () => sdk.api.chats.getSome({ filter: { roomId: sharedRoom.id } }, ), 
     { onResult: cs => cs.length === 2 && !!cs.find(c => c.id === sharedChat.id) && !!cs.find(c => c.id === sharedChat2.id) }
   )
   await async_test(
     `get-chats (shared, user2)`,
-    () => sdk2.api.chats.getSome({}, { roomId: sharedRoom.id }), 
+    () => sdk2.api.chats.getSome({ filter: { roomId: sharedRoom.id } }), 
     { onResult: cs => cs.length === 2 && !!cs.find(c => c.id === sharedChat.id) && !!cs.find(c => c.id === sharedChat2.id) }
   )
 
@@ -783,6 +843,65 @@ const chat_tests = async() => {
   )
 }
 
+const enduserAccessTests = async () => {
+  const email = 'enduser@tellescope.com'
+  const password = 'testpassword'
+
+  const enduser = await sdk.api.endusers.createOne({ email })
+  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) {
+    const endpoint = url_safe_path(n)
+    const model = schema[n as keyof typeof schema]
+
+    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' }
+      )
+    } 
+    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' }
+      )
+    } 
+    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' }
+      )
+    } 
+    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' }
+      )
+    } 
+    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' }
+      )
+    } 
+    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' }
+      )
+    } 
+  }
+
+  await sdk.api.endusers.deleteOne(enduser.id)
+}
+
 const tests: { [K in keyof ClientModelForName]: () => void } = {
   chats: chat_tests,
   endusers: enduser_tests,
@@ -795,6 +914,7 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
   chat_rooms: chat_room_tests,
   users: () => {},
   templates: () => {},
+  files: () => {},
 };
 
 (async () => {
@@ -803,7 +923,9 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
   log_header("API")
   await setup_tests()
   await multi_tenant_tests() // should come right after setup tests
+  await filterTests()
   await threadKeyTests()
+  await enduserAccessTests()
 
   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" }