@neuralinnovations/dataisland-sdk 0.0.1-dev4 → 0.0.1-dev41

package/src/middleware.ts

@@ -1,3 +1,5 @@
+import { Request, Response } from "./utils/request"
+
 /**
  * DataIsland App request middleware.
  */

package/src/services/acquiringService.ts

@@ -0,0 +1,50 @@
+import { Service } from "./service"
+import { RpcService } from "./rpcService"
+import { ResponseUtils } from "./responseUtils"
+import { AcquiringPlansResponse, CreateOrderResponse, CreateOrederData as CreateOrderData, UserAcquiringPlan } from "../dto/acquiringResponse"
+
+export class AcquiringService extends Service {
+
+  async create_order(key: string): Promise<CreateOrderData>{
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Acquiring/order")
+      .sendPostJson({
+        key: key
+      })
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to create order", response)
+    }
+
+
+    const order = (await response.json()) as CreateOrderResponse
+
+    return order.data
+  }
+
+  async get_plans(): Promise<AcquiringPlansResponse> {
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Acquiring/plans").sendGet()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to get acquiring plans", response)
+    }
+
+    const content = (await response.json()) as AcquiringPlansResponse
+
+    return content
+  }
+
+  async get_user_plan(): Promise<UserAcquiringPlan> {
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Acquiring/user/subscription").sendGet()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to get user subscription", response)
+    }
+
+    const content = (await response.json()) as UserAcquiringPlan
+
+    return content
+  }
+}

package/src/services/anonymousService.ts

@@ -0,0 +1,43 @@
+import { Service } from "./service"
+import { CookieService } from "./cookieService"
+import { createFingerprint } from "../utils/browserUtils"
+import { RpcService } from "./rpcService"
+import { ResponseUtils } from "./responseUtils"
+
+export class AnonymousService extends Service {
+
+  async getToken(): Promise<{ token: string, isValid: boolean }> {
+    const cookie = this.resolve(CookieService)!
+    let token = cookie.anonymousToken
+    if (token === undefined || token === null || token.length === 0) {
+      const fingerprint = createFingerprint()
+      const response = await this.context
+        .resolve(RpcService)
+        ?.requestBuilder("api/v1/Users/anonymous")
+        .sendPutJson({
+          info: {
+            fingerprint: JSON.stringify({
+              userAgent: fingerprint.get("userAgent"),
+              language: fingerprint.get("language"),
+              hardwareConcurrency: fingerprint.get("hardware_concurrency"),
+              cookieEnabled: fingerprint.get("cookie_enabled"),
+              pixelRatio: fingerprint.get("pixel_ratio")
+            })
+          }
+        })
+
+      if (ResponseUtils.isFail(response)) {
+        await ResponseUtils.throwError("Failed to create anonymous token", response)
+      }
+
+      token = (await response!.json() as { token: string }).token
+
+      cookie.anonymousToken = token!
+    }
+
+    return {
+      token: token!,
+      isValid: token !== undefined && token !== null && token.length > 0
+    }
+  }
+}

package/src/services/commandService.ts

@@ -3,7 +3,8 @@ import { Context } from "../context"
 import { Constructor } from "../internal/registry"
 
 export abstract class CommandHandler<T> {
-  constructor(protected readonly context: Context) {}
+  constructor(protected readonly context: Context) {
+  }
 
   resolve<T>(type: Constructor<T>): T | undefined {
     return this.context.resolve<T>(type)
@@ -12,7 +13,8 @@ export abstract class CommandHandler<T> {
   abstract execute(message: T): Promise<void>
 }
 
-export abstract class Command {}
+export abstract class Command {
+}
 
 export class CommandService extends Service {
   private readonly _registry: Map<

package/src/services/cookieService.ts

@@ -0,0 +1,16 @@
+import { Service } from "./service"
+import { getCookie, setCookie } from "../utils/browserUtils"
+
+export class CookieService extends Service {
+  get anonymousToken(): string | undefined {
+    return getCookie("anonymous-token")
+  }
+
+  get anonymousTokenIsValid(): boolean {
+    return this.anonymousToken !== undefined && this.anonymousToken !== null && this.anonymousToken.length > 0
+  }
+
+  set anonymousToken(value: string | undefined) {
+    setCookie("anonymous-token", value)
+  }
+}

package/src/services/httpMethod.ts

@@ -0,0 +1 @@
+export type HttpMethod = "POST" | "GET" | "PUT" | "DELETE" | "PATCH"

package/src/services/middlewareService.ts

@@ -1,6 +1,7 @@
 import { Service } from "./service"
 import { type Middleware } from "../middleware"
 import { type Disposable } from "../disposable"
+import { Request, Response } from "../utils/request"
 
 export class MiddlewareService extends Service {
   private _middlewares: Middleware[] = []

package/src/services/organizationService.ts

@@ -1,7 +1,7 @@
 import { Service } from "./service"
-import { Organizations } from "../storages/organizations"
+import { Organizations } from "../storages/organizations/organizations"
 import { OrganizationDto, UserSettings } from "../dto/userInfoResponse"
-import { OrganizationsImpl } from "../storages/organizations.impl"
+import { OrganizationsImpl } from "../storages/organizations/organizations.impl"
 
 export class OrganizationService extends Service {
   private _impl?: OrganizationsImpl

package/src/services/requestBuilder.ts

@@ -1,17 +1,19 @@
+// import { Request, Response, Headers, FormData } from "../utils/request"
+
 export class RequestBuilder {
-  private readonly _headers: Headers
+  private readonly _headers: Record<string, string>
   private readonly _searchParams: URLSearchParams
 
   constructor(
     private readonly _url: URL,
     private readonly _request: (req: Request) => Promise<Response>
   ) {
-    this._headers = new Headers()
+    this._headers = {}
     this._searchParams = new URLSearchParams()
   }
 
   public header(name: string, value: string): RequestBuilder {
-    this._headers.set(name, value)
+    this._headers[name] = value
     return this
   }
 
@@ -23,11 +25,11 @@ export class RequestBuilder {
     }
     if (headers instanceof Headers) {
       headers.forEach((value, name) => {
-        this._headers.set(name, value)
+        this._headers[name] = value
       })
     } else {
       Object.entries(headers).forEach(([name, value]) => {
-        this._headers.set(name, value)
+        this._headers[name] = value
       })
     }
     return this
@@ -58,7 +60,7 @@ export class RequestBuilder {
     const req = new Request(url, {
       method: "POST",
       headers: this._headers,
-      body
+      body: body
     })
 
     // discard content type
@@ -73,7 +75,7 @@ export class RequestBuilder {
   public async sendPostJson(body: object | null | undefined): Promise<Response> {
     const url = this._url
     url.search = this._searchParams.toString()
-    let json: string | null | undefined = null
+    let json: string | undefined = undefined
     if (body !== undefined && body !== null && typeof body === "object") {
       json = JSON.stringify(body)
     }
@@ -112,7 +114,7 @@ export class RequestBuilder {
   public async sendPutJson(body: object | null | undefined): Promise<Response> {
     const url = this._url
     url.search = this._searchParams.toString()
-    let json: string | null | undefined = null
+    let json: string | undefined = undefined
     if (body !== undefined && body !== null && typeof body === "object") {
       json = JSON.stringify(body)
     }

package/src/services/responseUtils.ts

@@ -1,3 +1,6 @@
+import { BadRequest } from "../dto/badRequestResponse"
+import { Response } from "../utils/request"
+
 export class ResponseUtils {
   public static isOk(response?: Response | null): boolean {
     return response !== undefined && response !== null && response.ok
@@ -7,6 +10,15 @@ export class ResponseUtils {
     return !ResponseUtils.isOk(response)
   }
 
+  public static async isLimitReached(response?: Response | null): Promise<boolean> {
+    if (response?.status == 15){
+      if (((await response?.json()) as BadRequest).code == 15){
+        return true
+      }
+    }
+    return false
+  }
+
   public static async throwError(
     message: string,
     response: Response | undefined | null

package/src/services/rpcService.ts

@@ -1,6 +1,7 @@
 import { Service, type ServiceContext } from "./service"
 import { MiddlewareService } from "./middlewareService"
 import { RequestBuilder } from "./requestBuilder"
+// import { Request, Response, Headers, fetch } from "../utils/request"
 
 /**
  * Options for the RpcService.

package/src/services/userProfileService.ts

@@ -1,21 +1,35 @@
 import { Service } from "./service"
 import { RpcService } from "./rpcService"
-import { UserProfile } from "../storages/userProfile"
+import { UserProfile } from "../storages/user/userProfile"
 import { UserInfoResponse } from "../dto/userInfoResponse"
 import { OrganizationService } from "./organizationService"
-import { UserProfileImpl } from "../storages/userProfile.impl"
+import { UserProfileImpl } from "../storages/user/userProfile.impl"
 import { ResponseUtils } from "./responseUtils"
 
 export class UserProfileService extends Service {
-  private readonly impl: UserProfileImpl = new UserProfileImpl()
+  private readonly impl: UserProfileImpl = new UserProfileImpl(this.context)
 
   get userProfile(): UserProfile {
     return this.impl
   }
 
+  async merge(anonymous_token: string) {
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Users/anonymous/merge")
+      .sendPostJson({
+        anonymousToken: anonymous_token
+      })
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to merge anonymous user", response)
+    }
+
+    await this.fetch()
+  }
+
   async fetch() {
     const rpc = this.resolve(RpcService) as RpcService
-    const response = await rpc.requestBuilder("api/v1/Users/self2").sendGet()
+    const response = await rpc.requestBuilder("api/v2/Users/self").sendGet()
     if (ResponseUtils.isFail(response)) {
       await ResponseUtils.throwError("Failed to fetch user profile", response)
     }

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

@@ -0,0 +1,160 @@
+import { Context } from "../../context"
+import {
+  AnswerDto,
+  AnswerStatus,
+  AnswerStepDto,
+  FetchAnswerResponse,
+  SourceDto,
+  StepType
+} from "../../dto/chatResponse"
+import { ResponseUtils } from "../../services/responseUtils"
+import { RpcService } from "../../services/rpcService"
+import { Answer, AnswerEvent, AnswerId } from "./answer"
+import { Chat } from "./chat"
+
+export class AnswerImpl extends Answer {
+
+  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,
+    private readonly context: Context) {
+    super()
+  }
+
+  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 initNew(id: AnswerId, question: string): Promise<AnswerImpl> {
+    this._id = id
+    this._question = question
+    this._answer = ""
+
+    await this.fetch()
+
+    return this
+  }
+
+  get id(): AnswerId {
+    return <AnswerId>this._id
+  }
+
+  get status(): AnswerStatus {
+    return <AnswerStatus>this._status
+  }
+
+  get question(): string {
+    return <string>this._question
+  }
+
+  get sources(): SourceDto[] {
+    return <SourceDto[]>this._sources
+  }
+
+  get tokens(): string {
+    return <string>this._answer
+  }
+
+  get timestamp(): number {
+    return <number>this._timestamp
+  }
+
+  public fetchAfter() {
+    if (this._status === undefined || this._status === AnswerStatus.RUNNING) {
+      setTimeout(async () => await this.fetch(), 300)
+    }
+  }
+
+  private getStep(type: StepType): AnswerStepDto | undefined {
+    return this._steps?.find(step => step.type === type)
+  }
+
+  async fetch(): Promise<void> {
+    // fetch answer from position 0
+    const position = 0
+    // fetch answer
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/answer/fetch")
+      .searchParam("chatId", this.chat.id)
+      .searchParam("questionId", this.id)
+      .searchParam("position", position.toString())
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Failed to fetch answer ${this.id}`, response)
+    }
+
+    // parse answer from the server's response
+    const answer = (await response!.json()) as FetchAnswerResponse
+
+    // update answer
+    this._status = <AnswerStatus>answer.status
+    this._steps = <AnswerStepDto[]>answer.steps
+
+    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
+        })
+      }
+    }
+
+    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
+      })
+    }
+
+    if (this.getStep(StepType.DONE) !== undefined) {
+      const step = this.getStep(StepType.DONE)
+      this._timestamp = Date.parse(step!.end_at)
+    }
+
+    this.fetchAfter()
+  }
+
+  async cancel(): Promise<void> {
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/answer/cancel")
+      .sendPutJson({
+        chat_id: this.chat.id,
+        uid: this.id
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to cancel a question", response)
+    }
+
+    this.dispatch({
+      type: AnswerEvent.CANCALLED,
+      data: this
+    })
+  }
+}

package/src/storages/chats/answer.ts

@@ -0,0 +1,53 @@
+import {
+  AnswerStatus,
+  SourceDto
+} from "../../dto/chatResponse"
+import { EventDispatcher } from "../../events"
+
+export type AnswerId = string
+export type StepId = string
+
+export enum AnswerEvent {
+  ADDED = "added",
+  CANCALLED = "cancelled",
+  FAILED = "failed",
+  UPDATED = "updated"
+}
+
+export abstract class Answer extends EventDispatcher<AnswerEvent, Answer> {
+
+  /**
+   * Answer id.
+   */
+  abstract get id(): AnswerId
+
+  /**
+   * Answer data object
+   */
+  abstract get question(): string
+
+  /**
+   * Answer tokens
+   */
+  abstract get tokens(): string
+
+  /**
+   * Answer status.
+   */
+  abstract get status(): AnswerStatus
+
+  /**
+   * Answer sources.
+   */
+  abstract get sources(): SourceDto[]
+
+  /**
+   * Answer time.
+   */
+  abstract get timestamp(): number
+
+  /**
+   * Cancel answer
+   */
+  abstract cancel(): Promise<void>
+}

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

@@ -0,0 +1,107 @@
+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 readonly _answers: AnswerImpl[] = []
+
+  private _content?: ChatDto
+
+  constructor(
+    private readonly context: Context,
+    public readonly organization: Organization
+  ) {
+    super()
+  }
+
+  async initFrom(chat: ChatDto): Promise<ChatImpl> {
+    this._content = chat
+
+    // 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
+  }
+
+  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 model(): string {
+    return <string>this._content?.model
+  }
+
+  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,55 @@
+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
+
+  /**
+   * Model.
+   */
+  abstract get model(): string
+
+  /**
+   * Answers list.
+   */
+  abstract get collection(): ReadonlyArray<Answer>
+
+  /**
+   * Get answer by id
+   * @param id answer id
+   */
+  abstract getAnswer(id: string): Answer
+
+  /**
+   * Ask new question in chat.
+   */
+  abstract ask(message: string, answerType: ChatAnswerType): Promise<Answer | undefined>
+
+}
+