@neuralinnovations/dataisland-sdk 0.0.1-dev25 → 0.0.1-dev27

package/src/storages/chats/answer.impl.ts

@@ -4,7 +4,6 @@ import {
   AnswerStatus,
   AnswerStepDto,
   FetchAnswerResponse,
-  FetchTokensResponse,
   SourceDto,
   StepType
 } from "../../dto/chatResponse"
@@ -14,11 +13,14 @@ import { Answer, AnswerEvent, AnswerId } from "./answer"
 import { Chat } from "./chat"
 
 export class AnswerImpl extends Answer {
-  private _content?: AnswerDto
 
   private _steps?: AnswerStepDto[]
   private _status?: AnswerStatus
   private _id?: AnswerId
+  private _question?: string
+  private _sources?: SourceDto[]
+  private _answer?: string
+  private _timestamp?: number
 
   constructor(
     private readonly chat: Chat,
@@ -26,75 +28,58 @@ export class AnswerImpl extends Answer {
     super()
   }
 
-  initFromData(answer: AnswerDto): AnswerImpl {
-    this._content = answer
+  initFromHistory(answer: AnswerDto): AnswerImpl {
     this._id = answer.id
+    this._question = answer.question
+    this._answer = answer.context
+    this._sources = answer.sources
+    this._timestamp = answer.timestamp
 
     return this
   }
 
-  async initFromId(id: AnswerId): Promise<AnswerImpl> {
+  async initNew(id: AnswerId, question: string): Promise<AnswerImpl> {
     this._id = id
+    this._question = question
+    this._answer = ""
 
-    // fetch answer
     await this.fetch()
 
-    this.dispatch({
-      type: AnswerEvent.ADDED,
-      data: this
-    })
-
     return this
   }
 
-  get id(): string {
-    return <string>this._id
+  get id(): AnswerId {
+    return <AnswerId>this._id
   }
 
   get status(): AnswerStatus {
     return <AnswerStatus>this._status
   }
 
-  get content(): AnswerDto {
-    if (this.status != AnswerStatus.RUNNING){
-      return <AnswerDto>this._content
-    }
-    throw new Error("Answer status is running, please use fetch() or fetch_tokens()")
+  get question(): string {
+    return <string>this._question
   }
 
-  private getStep(type: StepType): AnswerStepDto | undefined {
-    return this._steps?.find(step => step.type === type)
+  get sources(): SourceDto[] {
+    return <SourceDto[]>this._sources
   }
 
-  async sources(type: StepType): Promise<SourceDto[]> {
-    // fetch answer
-    await this.fetch()
-    // get step
-    const step = this.getStep(type)
-
-    // check step
-    if (!step) {
-      throw new Error(`Step with type ${type.toString()} is not found, answer: ${this.id}, organization: ${this.chat.organization.id}`)
-    }
+  get tokens(): string {
+    return <string>this._answer
+  }
 
-    // get sources
-    const response = await this.context
-      .resolve(RpcService)
-      ?.requestBuilder("api/v1/Chats/answer/sources")
-      .searchParam("chat_uid", this.chat.id)
-      .searchParam("uid", this.id)
-      .searchParam("step_id", step.id)
-      .sendGet()
+  get timestamp(): number {
+    return <number>this._timestamp
+  }
 
-    // check response status
-    if (ResponseUtils.isFail(response)) {
-      await ResponseUtils.throwError(`Failed to get sources for ${type.toString()}, answer: ${this.id}, organization: ${this.chat.organization.id}`, response)
+  public fetchAfter() {
+    if (this._status === undefined || this._status === AnswerStatus.RUNNING) {
+      setTimeout(async () => await this.fetch(), 300)
     }
+  }
 
-    // parse sources from the server's response
-    const sources = (await response!.json()).sources as SourceDto[]
-
-    return sources
+  private getStep(type: StepType): AnswerStepDto | undefined {
+    return this._steps?.find(step => step.type === type)
   }
 
   async fetch(): Promise<void> {
@@ -120,47 +105,37 @@ export class AnswerImpl extends Answer {
     // update answer
     this._status = <AnswerStatus>answer.status
     this._steps = <AnswerStepDto[]>answer.steps
-
-    this.dispatch({
-      type: AnswerEvent.UPDATED,
-      data: this
-    })
-
-    if (this._status != AnswerStatus.RUNNING){
-      await this.chat.update()
+    
+
+    if (this.getStep(StepType.GENERATE_ANSWER) !== undefined) {
+      const step = this.getStep(StepType.GENERATE_ANSWER)
+      const step_tokens = step?.tokens.join("")
+      if (this._answer !== step_tokens){
+        this._answer = step_tokens
+
+        this.dispatch({
+          type: AnswerEvent.UPDATED,
+          data: this
+        })
+      }
     }
-  }
-
-  async fetchTokens(type: StepType, token_start_at: number): Promise<FetchTokensResponse> {
-    // fetch answer
-    await this.fetch()
-    // get step
-    const step = this.getStep(type)
 
-    // check step
-    if (!step) {
-      throw new Error(`Step with type ${type.toString()} is not found`)
+    if (this.getStep(StepType.SOURCES) !== undefined && this._sources === undefined) {
+      const sources_step = this.getStep(StepType.SOURCES)
+      this._sources = sources_step?.sources 
+      
+      this.dispatch({
+        type: AnswerEvent.UPDATED,
+        data: this
+      })
     }
 
-    // get tokens
-    const response = await this.context
-      .resolve(RpcService)
-      ?.requestBuilder("api/v1/Chats/answer/fetch/tokens")
-      .searchParam("chat_uid", this.chat.id)
-      .searchParam("uid", this.id)
-      .searchParam("step_id", step.id)
-      .searchParam("token_start_at", token_start_at.toString())
-      .sendGet()
-
-    // check response status
-    if (ResponseUtils.isFail(response)) {
-      await ResponseUtils.throwError(`Failed to get sources for ${type.toString()}`, response)
+    if (this.getStep(StepType.DONE) !== undefined){
+      const step = this.getStep(StepType.DONE)
+      this._timestamp = Date.parse(step!.end_at)
     }
 
-    // parse tokens from the server's response
-    const tokens = (await response!.json()) as FetchTokensResponse
-
-    return tokens
+    this.fetchAfter()
   }
 
   async cancel(): Promise<void> {

package/src/storages/chats/answer.ts

@@ -1,9 +1,6 @@
 import {
-  AnswerDto,
   AnswerStatus,
-  FetchTokensResponse,
-  SourceDto,
-  StepType
+  SourceDto
 } from "../../dto/chatResponse"
 import { EventDispatcher } from "../../events"
 
@@ -13,6 +10,7 @@ export type StepId = string
 export enum AnswerEvent {
   ADDED = "added",
   CANCALLED = "cancelled",
+  FAILED = "failed",
   UPDATED = "updated"
 }
 
@@ -26,27 +24,27 @@ export abstract class Answer extends EventDispatcher<AnswerEvent, Answer> {
   /**
    * Answer data object
    */
-  abstract get content(): AnswerDto
+  abstract get question(): string
 
   /**
-   * Answer status.
+   * Answer tokens
    */
-  abstract get status(): AnswerStatus
+  abstract get tokens(): string
 
   /**
-   * Answer sources.
+   * Answer status.
    */
-  abstract sources(type: StepType): Promise<SourceDto[]>
+  abstract get status(): AnswerStatus
 
   /**
-   * Fetch answer.
+   * Answer sources.
    */
-  abstract fetch(): Promise<void>
+  abstract get sources(): SourceDto[]
 
   /**
-   * Fetch answer.
+   * Answer time.
    */
-  abstract fetchTokens(type: StepType, tokenStartAt: number): Promise<FetchTokensResponse>
+  abstract get timestamp(): number
 
   /**
    * Cancel answer

package/src/storages/chats/chat.impl.ts

@@ -1,6 +1,6 @@
 import { Chat, ChatAnswerType } from "./chat"
 import { Disposable } from "../../disposable"
-import { Answer } from "./answer"
+import { Answer, AnswerId } from "./answer"
 import { ChatDto } from "../../dto/chatResponse"
 import { Context } from "../../context"
 import { AnswerImpl } from "./answer.impl"
@@ -27,7 +27,7 @@ export class ChatImpl extends Chat implements Disposable {
     // init answers
     for (const ans of chat.answers) {
       // create answer implementation
-      const answer = await new AnswerImpl(this, this.context).initFromData(ans)
+      const answer = new AnswerImpl(this, this.context).initFromHistory(ans)
 
       // add answer to the collection
       this._answers.push(answer)
@@ -52,9 +52,9 @@ export class ChatImpl extends Chat implements Disposable {
     return this._isDisposed
   }
 
-  public getAnswer(id: string): Answer {
+  public getAnswer(id: AnswerId): Answer {
     const answer = this._answers.find(answer => answer.id === id)
-    if (answer){
+    if (answer) {
       return answer
     }
     throw new Error(`Answer with id ${id} is not found`)
@@ -80,7 +80,7 @@ export class ChatImpl extends Chat implements Disposable {
     const id = (await response!.json()).id
 
     // create answer implementation
-    const answer = await new AnswerImpl(this, this.context).initFromId(id)
+    const answer = await new AnswerImpl(this, this.context).initNew(id, message)
 
     // add answer to the collection
     this._answers.push(answer)
@@ -88,37 +88,6 @@ export class ChatImpl extends Chat implements Disposable {
     return answer
   }
 
-  async update(): Promise<void>{
-    const response = await this.context
-      .resolve(RpcService)
-      ?.requestBuilder("api/v1/Chats")
-      .searchParam("id", this.id)
-      .sendGet()
-
-    // check response status
-    if (ResponseUtils.isFail(response)) {
-      await ResponseUtils.throwError(`Failed to update chat ${this.id}`, response)
-    }
-
-    const chat = (await response!.json()).chat as ChatDto
-
-    this._content = chat
-
-    for (const ans of chat.answers) {
-      let answer = this._answers.find(answer => answer.id === ans.id)
-      if (!answer){
-        // create answer implementation
-        answer = new AnswerImpl(this, this.context).initFromData(ans)
-      }else{
-        this._answers.splice(this._answers.indexOf(answer), 1)
-
-        answer.initFromData(ans)
-      }
-      // add answer to the collection
-      this._answers.push(answer)
-    }
-  }
-
   dispose(): void {
     this._isDisposed = true
   }

package/src/storages/chats/chat.ts

@@ -41,9 +41,5 @@ export abstract class Chat {
    */
   abstract ask(message: string, answerType: ChatAnswerType): Promise<Answer>
 
-  /**
-   * Update chat
-   */
-  abstract update(): Promise<void>
 }
 

package/src/storages/files/file.impl.ts

@@ -3,22 +3,23 @@ import { Disposable } from "../../disposable"
 import { FileDto, FileProgressDto } from "../../dto/workspacesResponse"
 import { RpcService } from "../../services/rpcService"
 import { ResponseUtils } from "../../services/responseUtils"
-import { File } from "./file"
+import { File, FileStatus } from "./file"
 import { FilesEvent } from "./files"
 
 export class FileImpl extends File implements Disposable {
   private _isDisposed: boolean = false
   private _content?: FileDto
-  private _status?: FileProgressDto
-
+  private _progress?: FileProgressDto
 
   constructor(private readonly context: Context) {
     super()
   }
 
-  public initFrom(file: FileDto): File {
+  async initFrom(file: FileDto): Promise<File> {
     this._content = file
 
+    await this.updateStatus()
+
     return this
   }
 
@@ -42,8 +43,19 @@ export class FileImpl extends File implements Disposable {
     return <number>this._content?.createdAt
   }
 
-  get status(): FileProgressDto {
-    return <FileProgressDto>this._status
+  get progress(): FileProgressDto {
+    return <FileProgressDto>this._progress
+  }
+
+  get status(): FileStatus {
+    if (this._progress === undefined || this._progress.success === null ||
+      (this._progress.success && this._progress.completed_parts_count !== this._progress.file_parts_count)) {
+      return FileStatus.UPLOADING
+    } else if (this._progress.success) {
+      return FileStatus.SUCCESS
+    } else {
+      return FileStatus.FAILED
+    }
   }
 
   async url(): Promise<string> {
@@ -63,6 +75,12 @@ export class FileImpl extends File implements Disposable {
     return (await response!.json()).url
   }
 
+  public fetchAfter() {
+    if (this.status === FileStatus.UPLOADING) {
+      setTimeout(async () => await this.updateStatus(), 500)
+    }
+  }
+
   async updateStatus(): Promise<void> {
     const response = await this.context
       .resolve(RpcService)
@@ -74,14 +92,20 @@ export class FileImpl extends File implements Disposable {
       await ResponseUtils.throwError(`Failed to get file ${this.id}`, response)
     }
 
-    this._status = (await response!.json()).progress as FileProgressDto
-
-
-    // dispatch event, file updated
-    this.dispatch({
-      type: FilesEvent.UPDATED,
-      data: this
-    })
+    const prev_progress = this._progress
+    this._progress = (await response!.json()).progress as FileProgressDto
+
+    if (prev_progress === undefined ||
+      (this.progress.success !== null && this.progress.completed_parts_count > prev_progress.completed_parts_count) ||
+      this.status === FileStatus.SUCCESS ||
+      this.status === FileStatus.FAILED) {
+      // dispatch event, file updated
+      this.dispatch({
+        type: FilesEvent.UPDATED,
+        data: this
+      })
+    }
 
+    this.fetchAfter()
   }
 }

package/src/storages/files/file.ts

@@ -4,12 +4,18 @@ import { FilesEvent } from "./files"
 
 export type FileId = string
 
+export enum FileStatus {
+  UPLOADING = "uploading",
+  SUCCESS = "success",
+  FAILED = "failed"
+}
+
 /**
  * File.
  */
 export abstract class File extends EventDispatcher<
-FilesEvent,
-File
+  FilesEvent,
+  File
 > {
   /**
    * File id.
@@ -26,15 +32,18 @@ File
    */
   abstract get createdAt(): number
 
-  abstract get status(): FileProgressDto
+  /**
+   * File uploading progress
+   */
+  abstract get progress(): FileProgressDto
 
   /**
-   * Get temporary url.
+   * File uploading status
    */
-  abstract url(): Promise<string>
+  abstract get status(): FileStatus
 
   /**
-   * Get file status.
+   * Get temporary url.
    */
-  abstract updateStatus(): Promise<void>
+  abstract url(): Promise<string>
 }

package/src/storages/files/files.impl.ts

@@ -22,14 +22,14 @@ export class FilesImpl extends Files {
 
   async upload(files: any[]): Promise<File[]> {
     const loaded_files = []
-    for ( const file of files ){
+    for (const file of files) {
       loaded_files.push(await this.internalUpload(file))
     }
     return loaded_files
   }
 
   async delete(ids: string[]): Promise<void> {
-    for ( const id of ids ){
+    for (const id of ids) {
       await this.internalDeleteFile(id)
     }
   }
@@ -135,7 +135,7 @@ export class FilesImpl extends Files {
     for (const fl of files.files) {
 
       // create file implementation
-      const file = new FileImpl(this.context).initFrom(fl)
+      const file = await new FileImpl(this.context).initFrom(fl)
 
       // add file to the collection
       filesList.files.push(file)
@@ -175,7 +175,9 @@ export class FilesImpl extends Files {
     const result = (await response!.json()).file as FileDto
 
     // create file implementation
-    const fileImpl = new FileImpl(this.context).initFrom(result)
+    const fileImpl = new FileImpl(this.context)
+
+    await fileImpl.initFrom(result)
 
     // TODO: why is this here?
     this.filesList?.files.push(fileImpl)

package/src/storages/workspaces/workspaces.impl.ts

@@ -8,6 +8,8 @@ import { RpcService } from "../../services/rpcService"
 import { OrganizationWorkspaces } from "../../dto/userInfoResponse"
 import { WorkspaceDto } from "../../dto/workspacesResponse"
 import { ResponseUtils } from "../../services/responseUtils"
+import { UserProfileService } from "../../services/userProfileService"
+import { UserProfile } from "../user/userProfile"
 
 export class WorkspacesImpl extends Workspaces {
   private readonly _workspaces: WorkspaceImpl[] = []
@@ -184,7 +186,8 @@ export class WorkspacesImpl extends Workspaces {
 
     // check response status
     if (ResponseUtils.isFail(response)) {
-      await ResponseUtils.throwError(`Failed to fetch workspaces in organization: ${organizationId}`, response)
+      const userProfile = this.context.resolve(UserProfileService)?.userProfile as UserProfile
+      await ResponseUtils.throwError(`Failed to fetch workspaces in organization: ${organizationId}, userId: ${userProfile.id}, email: ${userProfile.email}`, response)
     }
 
     // parse workspaces from the server's response

package/src/unitTest.ts

@@ -3,7 +3,7 @@ export enum UnitTest {
   DO_NOT_START = 1 << 0,
   DO_NOT_PRINT_INITIALIZED_LOG = 1 << 1,
 
-  DEFAULT = DO_NOT_START | DO_NOT_PRINT_INITIALIZED_LOG
+  DO_NOT_START_SDK = DO_NOT_START | DO_NOT_PRINT_INITIALIZED_LOG
 }
 
 export type UnitTestProfileSyncAction = () => void
@@ -17,7 +17,7 @@ class AppSdkUnitTest {
   }
 
   public static async test(
-    unitTest: UnitTest = UnitTest.DEFAULT,
+    unitTest: UnitTest = UnitTest.DO_NOT_START_SDK,
     func: UnitTestProfileSyncAction | UnitTestProfileAsyncAction
   ): Promise<void> {
     this._stack.push(unitTest)
@@ -38,7 +38,7 @@ class AppSdkUnitTest {
 }
 
 export const appTest = async (
-  unitTest: UnitTest = UnitTest.DEFAULT,
+  unitTest: UnitTest = UnitTest.DO_NOT_START_SDK,
   func: UnitTestProfileSyncAction | UnitTestProfileAsyncAction
 ): Promise<void> => {
   await AppSdkUnitTest.test(unitTest, func)