@neuralinnovations/dataisland-sdk 0.0.1-dev7 → 0.0.1-dev71

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

@@ -0,0 +1,139 @@
+import { Chat, ChatAnswerType } from "./chat"
+import { Disposable } from "../../disposable"
+import { Answer, AnswerId } from "./answer"
+import {ChatDto} from "../../dto/chatResponse"
+import { Context } from "../../context"
+import { AnswerImpl } from "./answer.impl"
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+import { Organization } from "../organizations/organization"
+
+export class ChatImpl extends Chat implements Disposable {
+  private _isDisposed: boolean = false
+  private _answers: AnswerImpl[] = []
+
+  private _content?: ChatDto
+
+  constructor(
+    private readonly context: Context,
+    public readonly organization: Organization
+  ) {
+    super()
+  }
+
+  async initFrom(chat: ChatDto): Promise<ChatImpl> {
+    this._content = chat
+
+    this._answers = []
+    // init answers
+    for (const ans of chat.answers) {
+      // create answer implementation
+      const answer = new AnswerImpl(this, this.context).initFromHistory(ans)
+
+      // add answer to the collection
+      this._answers.push(answer)
+    }
+
+    return this
+  }
+
+  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(
+        `Get chat for id ${this.id} is failed`,
+        response
+      )
+    }
+
+    // parse chat from the server's response
+    const chat = (await response!.json() as { chat: ChatDto }).chat as ChatDto
+
+    await this.initFrom(chat)
+  }
+
+  get id(): string {
+    return <string>this._content?.id
+  }
+
+  get name(): string {
+    return <string>this._content?.name
+  }
+
+  get fileId(): string {
+    return <string>this._content?.fileId
+  }
+
+  get workspaceIds(): string[] {
+    return <string[]>this._content?.workspaceIds
+  }
+
+  get model(): string {
+    return <string>this._content?.model
+  }
+
+  get clientContext(): string {
+    return <string>this._content?.clientContext
+  }
+
+  get collection(): readonly Answer[] {
+    return <Answer[]>this._answers
+  }
+
+  get isDisposed(): boolean {
+    return this._isDisposed
+  }
+
+  public getAnswer(id: AnswerId): Answer {
+    const answer = this._answers.find(answer => answer.id === id)
+    if (answer) {
+      return answer
+    }
+    throw new Error(`Answer with id ${id} is not found`)
+  }
+
+  async ask(message: string, answerType: ChatAnswerType): Promise<Answer | undefined> {
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/question")
+      .sendPutJson({
+        chatId: this.id,
+        questionMessage: message,
+        isLongAnswer: (answerType === ChatAnswerType.LONG)
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+      await ResponseUtils.throwError(`Failed to ask a question, organization: ${this.organization.id}`, response)
+    }
+
+    // parse answer id from the server's response
+    const id = (await response!.json() as { id: string }).id
+
+    // create answer implementation
+    const answer = await new AnswerImpl(this, this.context).initNew(id, message)
+
+    // add answer to the collection
+    this._answers.push(answer)
+
+    return answer
+  }
+
+
+
+  dispose(): void {
+    this._isDisposed = true
+  }
+
+}

package/src/storages/chats/chat.ts

@@ -0,0 +1,70 @@
+import { Answer } from "./answer"
+import { Organization } from "../organizations/organization"
+
+export type ChatId = string
+
+export enum ChatAnswerType {
+  SHORT = "short",
+  LONG = "long"
+}
+
+export abstract class Chat {
+
+  /**
+   * Organization.
+   */
+  abstract get organization(): Organization
+
+  /**
+   * Chat id.
+   */
+  abstract get id(): ChatId
+
+  /**
+   * Chat name.
+   */
+  abstract get name(): string
+
+  /**
+   * Connected file ID.
+   */
+  abstract get fileId(): string
+
+  /**
+   * Connected workspace ID.
+   */
+  abstract get workspaceIds(): string[]
+
+  /**
+   * Model.
+   */
+  abstract get model(): string
+
+  /**
+   * Added client context.
+   */
+  abstract get clientContext(): string
+
+  /**
+   * Answers list.
+   */
+  abstract get collection(): ReadonlyArray<Answer>
+
+  /**
+   * Get answer by id
+   * @param id answer id
+   */
+  abstract getAnswer(id: string): Answer
+
+  /**
+   * Update chat
+   */
+  abstract update(): Promise<void>
+
+  /**
+   * Ask new question in chat.
+   */
+  abstract ask(message: string, answerType: ChatAnswerType): Promise<Answer | undefined>
+
+}
+

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

@@ -0,0 +1,255 @@
+import { Context } from "../../context"
+import { ChatDto, ChatListResponse } from "../../dto/chatResponse"
+import { ResponseUtils } from "../../services/responseUtils"
+import { RpcService } from "../../services/rpcService"
+import { OrganizationImpl } from "../organizations/organization.impl"
+import { OrganizationId } from "../organizations/organizations"
+import { Chat } from "./chat"
+import { ChatImpl } from "./chat.impl"
+import { Chats, ChatsEvent } from "./chats"
+
+export class ChatsImpl extends Chats {
+  private readonly _chats: Chat[] = []
+
+  constructor(
+    public readonly organization: OrganizationImpl,
+    private readonly context: Context
+  ) {
+    super()
+  }
+
+  async initFrom(organizationId: OrganizationId): Promise<void> {
+    // init chats from the server's response
+    const limit = 100
+    const page = 0
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/list")
+      .searchParam("organizationId", organizationId)
+      .searchParam("limit", limit.toString())
+      .searchParam("page", page.toString())
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Chats list org id:${organizationId}, page:${page}, limit:${limit}, failed`,
+        response
+      )
+    }
+
+    // parse chats from the server's response
+    const chats = (await response!.json()) as ChatListResponse
+
+    // init chats
+    for (const cht of chats.chats) {
+      // create chat implementation
+      const chat = await new ChatImpl(this.context, this.organization).initFrom(cht)
+
+      // add chat to the collection
+      this._chats.push(chat)
+
+      // dispatch event
+      this.dispatch({
+        type: ChatsEvent.ADDED,
+        data: chat
+      })
+    }
+
+  }
+
+  get collection(): readonly Chat[] {
+    return this._chats
+  }
+
+  get(id: string): Chat {
+    return <Chat>this.tryGet(id)
+  }
+
+  tryGet(id: string): Chat | undefined {
+    return this._chats.find(chat => chat.id === id)
+  }
+
+  async create(model: string, clientContext: string = ""): Promise<Chat | undefined> {
+    if (model === undefined || model === null) {
+      throw new Error("Create chat, model is undefined or null")
+    }
+
+    if (model.length === 0) {
+      throw new Error("Create chat, model is empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/workspaces")
+      .sendPostJson({ organizationId: this.organization.id, model: model, clientContext: clientContext })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat, organization: ${this.organization.id}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.push(chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+  async createWithFile(fileId: string): Promise<Chat | undefined> {
+    if (fileId === undefined || fileId === null) {
+      throw new Error("Create chat with file, id is undefined or null")
+    }
+    if (fileId.length === 0 || fileId.trim().length === 0) {
+      throw new Error("Create chat with file, id is empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/file")
+      .sendPostJson({ 
+        organizationId: this.organization.id,
+        fileId: fileId,
+        model: "search"
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat, organization: ${this.organization.id}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.push(chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+  async createWithWorkspace(workspaceId: string, clientContext: string = ""): Promise<Chat | undefined> {
+    if (workspaceId === undefined || workspaceId === null) {
+      throw new Error("Create chat with workspace, id is undefined or null")
+    }
+    if (workspaceId.length === 0 || workspaceId.trim().length === 0) {
+      throw new Error("Create chat with workspace, id is empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/workspaces")
+      .sendPostJson({
+        organizationId: this.organization.id,
+        model: "search",
+        clientContext: clientContext,
+        workspaceIds: [workspaceId]
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat in workspace, organization: ${this.organization.id}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.push(chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+
+
+
+  async delete(id: string): Promise<void> {
+    // get chat by id
+    const chat = <ChatImpl>this.tryGet(id)
+
+    // check if chat is found
+    if (!chat) {
+      throw new Error(`Chat ${id} is not found, organization: ${this.organization.id}`)
+    }
+
+    // send delete request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats")
+      .searchParam("id", id)
+      .sendDelete()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Failed to delete chat: ${id}, organization: ${this.organization.id}`,
+        response
+      )
+    }
+
+    // remove chat from the collection
+    const index = this._chats.indexOf(<ChatImpl>chat)
+    if (index < 0) {
+      throw new Error(`Chat ${id} is not found, organization: ${this.organization.id}`)
+    }
+    this._chats.splice(index, 1)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.REMOVED,
+      data: chat
+    })
+  }
+}

package/src/storages/chats/chats.ts

@@ -0,0 +1,60 @@
+import { EventDispatcher } from "../../events"
+import { Chat, ChatId } from "./chat"
+import { Organization } from "../organizations/organization"
+
+export enum ChatsEvent {
+  ADDED = "added",
+  REMOVED = "removed"
+}
+
+/**
+ * Chats storage.
+ */
+export abstract class Chats extends EventDispatcher<ChatsEvent, Chat> {
+
+  /**
+   * Organization.
+   */
+  abstract get organization(): Organization
+
+  /**
+   * Chats list.
+   */
+  abstract get collection(): ReadonlyArray<Chat>
+
+  /**
+   * Create new chat.
+   */
+  abstract create(model: string, clientContext: string): Promise<Chat | undefined>
+
+  /**
+   * Create chat with specific file
+   * @param fileId 
+   */
+  abstract createWithFile(fileId: string): Promise<Chat | undefined>
+
+  /**
+   * Create chat with specific workspace
+   * @param workspaceId
+   * @param clientContext
+   */
+  abstract createWithWorkspace(workspaceId: string, clientContext: string): Promise<Chat | undefined>
+
+  /**
+   * Get chat by id.
+   * @param id
+   */
+  abstract get(id: ChatId): Chat
+
+  /**
+   * Try to get chat by id.
+   * @param id
+   */
+  abstract tryGet(id: ChatId): Chat | undefined
+
+  /**
+   * Delete chat.
+   * @param id
+   */
+  abstract delete(id: ChatId): Promise<void>
+}

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

@@ -0,0 +1,162 @@
+import {Context} from "../../context"
+import {Disposable} from "../../disposable"
+import {
+  FileDto,
+  FileProgressDto,
+  MetadataDto
+} from "../../dto/workspacesResponse"
+import {RpcService} from "../../services/rpcService"
+import {ResponseUtils} from "../../services/responseUtils"
+import {File, FileStatus} from "./file"
+import {FilesEvent} from "./files"
+import {isNullOrUndefined} from "../../utils/utils"
+
+export class FileImpl extends File implements Disposable {
+  private _isDisposed: boolean = false
+  private _content?: FileDto
+  private _progress?: FileProgressDto
+
+  constructor(private readonly context: Context) {
+    super()
+  }
+
+  async initFrom(file: FileDto): Promise<File> {
+    this._content = file
+
+    await this.updateStatus()
+
+    return this
+  }
+
+  get isDisposed(): boolean {
+    return this._isDisposed
+  }
+
+  dispose(): void {
+    this._isDisposed = true
+  }
+
+  get id(): string {
+    return <string>this._content?.id
+  }
+
+  get name(): string {
+    return <string>this._content?.name
+  }
+
+  get description(): string {
+    return <string>this._content?.description
+  }
+
+  get metadata(): MetadataDto[] {
+    const metadataString = <string>this._content?.fileMetadata
+    if (metadataString === null || metadataString === undefined){
+      return []
+    }
+    return <MetadataDto[]>JSON.parse(metadataString)
+  }
+
+  get createdAt(): number {
+    return <number>this._content?.createdAt
+  }
+
+  get modifiedAt(): number {
+    return <number>this._content?.modifiedAt
+  }
+  
+  get url(): string {
+    return <string>this._content?.url
+  }
+
+  get previewUrl(): string {
+    return <string>this._content?.previewUrl
+  }
+
+  get progress(): FileProgressDto {
+    return <FileProgressDto>this._progress
+  }
+
+  get status(): FileStatus {
+
+    if (
+      isNullOrUndefined(this._progress) || isNullOrUndefined(this._progress.success)
+      || (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
+    }
+  }
+
+  public fetchAfter() {
+    if (this.status === FileStatus.UPLOADING) {
+      setTimeout(async () => await this.updateStatus(), 2000)
+    }
+  }
+
+  async updateStatus(): Promise<void> {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Files/fetch")
+      .searchParam("id", this.id)
+      .sendGet()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Failed to get file ${this.id}`, response)
+    }
+
+    const prev_progress = this._progress
+    this._progress = (await response!.json() as {
+      progress: FileProgressDto
+    }).progress as FileProgressDto
+
+    if (isNullOrUndefined(prev_progress) ||
+      (!isNullOrUndefined(this.progress.success) && 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()
+  }
+
+  async update(name: string, metadata: MetadataDto[], description?: string){
+    if (!this._content) {
+      throw new Error("File is not loaded.")
+    }
+
+    if (name === undefined || metadata === undefined || name === null || metadata === null ){
+      throw new Error("File update, one of parameters is undefined or null")
+    }
+
+    const metadataString = JSON.stringify(metadata)
+
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Files")
+      .sendPutJson({
+        fileId: this.id,
+        name: name,
+        description: description ?? this.description,
+        metadata: metadataString
+      })
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to update file", response)
+    }
+
+    this._content = (await response!.json() as {
+      file: FileDto
+    }).file as FileDto
+
+    this.dispatch({
+      type: FilesEvent.UPDATED,
+      data: this
+    })
+  }
+}