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

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)
     }
@@ -109,10 +111,26 @@ export class RequestBuilder {
     )
   }
 
+  public async sendDeleteJson(body: object | null | undefined): Promise<Response> {
+    const url = this._url
+    url.search = this._searchParams.toString()
+    let json: string | undefined = undefined
+    if (body !== undefined && body !== null && typeof body === "object") {
+      json = JSON.stringify(body)
+    }
+    return await this._request(
+      new Request(url, {
+        method: "DELETE",
+        headers: this._headers,
+        body: json
+      })
+    )
+  }
+
   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)
     }
@@ -124,4 +142,26 @@ export class RequestBuilder {
       })
     )
   }
+
+  public async sendPutFormData(body: FormData): Promise<Response> {
+    const url = this._url
+
+    // set search params
+    url.search = this._searchParams.toString()
+
+    // create request
+    const req = new Request(url, {
+      method: "PUT",
+      headers: this._headers,
+      body: body
+    })
+
+    // discard content type
+    const reqAny = req as any
+    reqAny.discardContentType = true
+
+    return await this._request(
+      req
+    )
+  }
 }

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,36 @@
 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"
+import { OrganizationsEvent } from "../storages/organizations/organizations"
 
 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)
     }
@@ -34,5 +49,22 @@ export class UserProfileService extends Service {
       content.organizations,
       content.user.settings
     )
+
+    organizationService.organizations.subscribe(async (event) => {
+      this.updateUserSettings(event.data.id)
+    }, OrganizationsEvent.CURRENT_CHANGED)
+  }
+
+  async updateUserSettings(activeOrgId?: string, activeWorkspaceId?: string): Promise<void>{
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Users/settings").sendPutJson({
+      settings: {
+        activeOrganizationId: activeOrgId,
+        activeWorkspaceId: activeWorkspaceId
+      }
+    })
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to update user settings", response)
+    }
   }
 }

package/src/storages/acquirings/acquiring.impl.ts

@@ -0,0 +1,132 @@
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+import {
+  AcquiringPlansResponse,
+  OrderResponse,
+  OrderData,
+  UserAcquiringPlan,
+  GetOrderStateResponse,
+  AcquiringPlan,
+  AcquiringSegmentData,
+  UnsubscribeResponse
+} from "../../dto/acquiringResponse"
+import { Acquiring } from "./acquiring"
+import { Context } from "../../context"
+
+export class AcquiringImpl implements Acquiring {
+  private _userPlan?: UserAcquiringPlan
+  private _plans?: AcquiringPlan[]
+  private _limitSegments?: AcquiringSegmentData[]
+
+  constructor(
+    private readonly context: Context) {
+  }
+
+  get userPlan(): UserAcquiringPlan {
+    return this._userPlan!
+  }
+
+  get plans(): AcquiringPlan[] {
+    return this._plans!
+  }
+
+  get limitSegments(): AcquiringSegmentData[] {
+    return this._limitSegments!
+  }
+
+  async initialize() {
+    const userPlanPromise = this.getUserPlan()
+    const plansPromise = this.getPlans()
+    const promises = [
+      userPlanPromise,
+      plansPromise
+    ]
+    await Promise.all(promises)
+
+    this._userPlan = await userPlanPromise
+    const {
+      plans,
+      limitSegments
+    } = await plansPromise
+    this._plans = plans
+    this._limitSegments = limitSegments
+  }
+
+  async createOrder(key: string): Promise<OrderData> {
+    const rpc = this.context.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 OrderResponse
+
+    return order.data
+  }
+
+  async unsubscribe(): Promise<UnsubscribeResponse> {
+    const rpc = this.context.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Acquiring/unsubscribe").sendDelete()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to unsubscribe", response)
+    }
+
+    const order = (await response.json()) as UnsubscribeResponse
+
+    return order
+  }
+
+  async getPlans(): Promise<AcquiringPlansResponse> {
+    const rpc = this.context.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
+    this._plans = content.plans
+    this._limitSegments = content.limitSegments
+
+    return content
+  }
+
+  async getUserPlan(): Promise<UserAcquiringPlan> {
+    const rpc = this.context.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
+    this._userPlan = content
+
+    return content
+  }
+
+  async getOrder(orderId: string): Promise<GetOrderStateResponse> {
+    const rpc = this.context.resolve(RpcService) as RpcService
+    const response = await rpc
+      .requestBuilder("api/v1/Acquiring/order/state")
+      .searchParam("orderId", orderId)
+      .sendGet()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to get order", response)
+    }
+
+    const content = (await response.json()) as GetOrderStateResponse
+
+    return content
+  }
+}

package/src/storages/acquirings/acquiring.ts

@@ -0,0 +1,54 @@
+import {
+  AcquiringPlan,
+  AcquiringPlansResponse, AcquiringSegmentData,
+  OrderData, GetOrderStateResponse,
+  UserAcquiringPlan, UnsubscribeResponse
+} from "../../dto/acquiringResponse"
+
+/**
+ * Acquiring service
+ */
+export abstract class Acquiring {
+
+  /**
+   * Plan
+   */
+  abstract get userPlan(): UserAcquiringPlan
+
+  /**
+   * Plans
+   */
+  abstract get plans(): AcquiringPlan[]
+
+  /**
+   * Limit segments
+   */
+  abstract get limitSegments(): AcquiringSegmentData[]
+
+  /**
+   * Create order
+   * @param key
+   */
+  abstract createOrder(key: string): Promise<OrderData>
+
+  /**
+   * Unsubscribe
+   */
+  abstract unsubscribe(): Promise<UnsubscribeResponse>
+
+  /**
+   * Update plans
+   */
+  abstract getPlans(): Promise<AcquiringPlansResponse>
+
+  /**
+   * Update user plan
+   */
+  abstract getUserPlan(): Promise<UserAcquiringPlan>
+
+  /**
+   * Get order
+   * @param orderId
+   */
+  abstract getOrder(orderId: string): Promise<GetOrderStateResponse>
+}

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

@@ -0,0 +1,178 @@
+import {Context} from "../../context"
+import {
+  AnswerDto,
+  AnswerStatus,
+  AnswerStepDto,
+  FetchAnswerResponse,
+  SourceDto,
+  StepStatus,
+  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.status == AnswerStatus.CANCELED || this.status == AnswerStatus.FAIL){
+      this.dispatch({
+        type: AnswerEvent.UPDATED,
+        data: this
+      })
+    }
+
+    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
+      })
+    }
+
+    const doneStep = this.getStep(StepType.DONE)
+    if (doneStep !== undefined) {
+      if (doneStep.status == StepStatus.FAIL || doneStep.status == StepStatus.CANCELED){
+        this.dispatch({
+          type: AnswerEvent.UPDATED,
+          data: this
+        })
+      }else {
+        const step = this.getStep(StepType.DONE)
+        this._timestamp = Date.parse(step!.end_at)
+
+        await this.chat.update()
+      }
+    } else {
+      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>
+}