@neuralinnovations/dataisland-sdk 0.0.1-dev9 → 0.1.0

package/src/services/librariesService.ts

@@ -0,0 +1,22 @@
+import { Service, ServiceContext } from "./service"
+import {LibrariesImpl} from "../storages/library/libraries.impl"
+import {Libraries} from "../storages/library/libraries"
+
+export class LibrariesService extends Service {
+  private readonly _libraries: LibrariesImpl
+
+  constructor(serviceContext: ServiceContext) {
+    super(serviceContext)
+
+    this._libraries = new LibrariesImpl(serviceContext.context)
+  }
+
+  async initialize(): Promise<void> {
+    return await this._libraries.initialize()
+  }
+
+  get libraries(): Libraries {
+    return this._libraries
+  }
+
+}

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/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,13 +111,29 @@ export class RequestBuilder {
     )
   }
 
-  public async sendPutJson(body: object | null | undefined): Promise<Response> {
+  public async sendDeleteJson(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)
     }
+    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 | undefined = undefined
+    if (body !== undefined && body !== null && (typeof body === "object" || Array.isArray(body))) {
+      json = JSON.stringify(body)
+    }
     return await this._request(
       new Request(url, {
         method: "PUT",
@@ -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

@@ -5,17 +5,32 @@ import { UserInfoResponse } from "../dto/userInfoResponse"
 import { OrganizationService } from "./organizationService"
 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

@@ -1,24 +1,27 @@
-import { Context } from "../../context"
+import {Context} from "../../context"
 import {
   AnswerDto,
   AnswerStatus,
   AnswerStepDto,
   FetchAnswerResponse,
-  FetchTokensResponse,
   SourceDto,
+  StepStatus,
   StepType
 } from "../../dto/chatResponse"
-import { ResponseUtils } from "../../services/responseUtils"
-import { RpcService } from "../../services/rpcService"
-import { Answer, AnswerId } from "./answer"
-import { Chat } from "./chat"
+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 _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,66 +29,58 @@ export class AnswerImpl extends Answer {
     super()
   }
 
-  async initFromData(answer: AnswerDto): Promise<AnswerImpl> {
-    this._content = answer
+  initFromHistory(answer: AnswerDto): AnswerImpl {
     this._id = answer.id
-
-    // fetch answer
-    await this.fetch()
+    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()
 
     return this
   }
 
-  get id(): string {
-    return <string>this._id
+  get id(): AnswerId {
+    return <AnswerId>this._id
   }
 
   get status(): AnswerStatus {
     return <AnswerStatus>this._status
   }
 
-  private getStep(type: StepType): AnswerStepDto | undefined {
-    return this._steps?.find(step => step.type === type)
+  get question(): string {
+    return <string>this._question
   }
 
-  async sources(type: StepType): Promise<SourceDto[]> {
-    // fetch answer
-    await this.fetch()
-    // get step
-    const step = this.getStep(type)
+  get sources(): SourceDto[] {
+    return <SourceDto[]>this._sources
+  }
 
-    // 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> {
@@ -111,38 +106,53 @@ export class AnswerImpl extends Answer {
     // update answer
     this._status = <AnswerStatus>answer.status
     this._steps = <AnswerStepDto[]>answer.steps
-  }
 
-  async fetchTokens(type: StepType, token_start_at: number): Promise<FetchTokensResponse> {
-    // fetch answer
-    await this.fetch()
-    // get step
-    const step = this.getStep(type)
+    if (this.status == AnswerStatus.CANCELED || this.status == AnswerStatus.FAIL){
+      this.dispatch({
+        type: AnswerEvent.UPDATED,
+        data: this
+      })
+    }
 
-    // check step
-    if (!step) {
-      throw new Error(`Step with type ${type.toString()} is not found`)
+    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
+        })
+      }
     }
 
-    // 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()
+    if (this.getStep(StepType.SOURCES) !== undefined && this._sources === undefined) {
+      const sources_step = this.getStep(StepType.SOURCES)
+      this._sources = sources_step?.sources
 
-    // check response status
-    if (ResponseUtils.isFail(response)) {
-      await ResponseUtils.throwError(`Failed to get sources for ${type.toString()}`, response)
+      this.dispatch({
+        type: AnswerEvent.UPDATED,
+        data: this
+      })
     }
 
-    // parse tokens from the server's response
-    const tokens = (await response!.json()) as FetchTokensResponse
-
-    return tokens
+    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> {
@@ -159,5 +169,10 @@ export class AnswerImpl extends Answer {
     if (ResponseUtils.isFail(response)) {
       await ResponseUtils.throwError("Failed to cancel a question", response)
     }
+
+    this.dispatch({
+      type: AnswerEvent.CANCALLED,
+      data: this
+    })
   }
 }