@neuralinnovations/dataisland-sdk 0.0.1-dev73 → 0.0.1-dev75

package/src/storages/library/libraryPage.ts

@@ -0,0 +1,37 @@
+import {LibraryFolder} from "./libraryFolder"
+import {File} from "../files/file"
+
+
+export abstract class LibraryPage {
+
+  /**
+   * Get current page.
+   */
+  abstract get parents(): string[]
+
+  /**
+   * Get page files.
+   */
+  abstract get files(): File[]
+
+  /**
+   * Get page folders
+   */
+  abstract get folders(): LibraryFolder[]
+
+  /**
+   * Get pages count.
+   */
+  abstract get pages(): number
+
+  /**
+   * Get total count.
+   */
+  abstract get total(): number
+
+  /**
+   * Get current page.
+   */
+  abstract get page(): number
+
+}

package/src/storages/organizations/organization.impl.ts

@@ -36,6 +36,8 @@ import {
 } from "../../dto/apiKeyResponse"
 import {IconResponse} from "../../dto/workspacesResponse"
 import {UploadFile} from "../files/files"
+import {QueryFlowsImpl} from "../queryFlows/queryFlows.impl"
+import {QueryFlows} from "../queryFlows/queryFlows"
 
 export class OrganizationImpl extends Organization implements Disposable {
   private _isDisposed: boolean = false
@@ -43,6 +45,7 @@ export class OrganizationImpl extends Organization implements Disposable {
   private _content?: OrganizationDto
   private readonly _workspaces: WorkspacesImpl
   private readonly _accessGroups: GroupsImpl
+  private readonly _queryFlows: QueryFlowsImpl
   private readonly _chats: ChatsImpl
 
   constructor(private readonly context: Context) {
@@ -50,6 +53,7 @@ export class OrganizationImpl extends Organization implements Disposable {
     this._workspaces = new WorkspacesImpl(this, this.context)
     this._accessGroups = new GroupsImpl(this, this.context)
     this._chats = new ChatsImpl(this, this.context)
+    this._queryFlows = new QueryFlowsImpl(this, this.context)
   }
 
   public async initFrom(
@@ -63,7 +67,8 @@ export class OrganizationImpl extends Organization implements Disposable {
     const promises = [
       this._workspaces.initFrom(content.id),
       this._chats.initFrom(content.id),
-      this._accessGroups.initialize()
+      this._accessGroups.initialize(),
+      this._queryFlows.init()
     ]
 
     await Promise.all(promises)
@@ -107,6 +112,10 @@ export class OrganizationImpl extends Organization implements Disposable {
     return this._accessGroups
   }
 
+  get queryFlows(): QueryFlows {
+    return this._queryFlows
+  }
+
   get chats(): Chats {
     return this._chats
   }

package/src/storages/organizations/organization.ts

@@ -16,6 +16,7 @@ import {QuizData} from "../../dto/quizResponse"
 import {InviteResponse} from "../../dto/invitesResponse"
 import { OrganizationApiKey } from "../../dto/apiKeyResponse"
 import {UploadFile} from "../files/files"
+import {QueryFlows} from "../queryFlows/queryFlows"
 
 /**
  * Organization event.
@@ -66,6 +67,11 @@ export abstract class Organization extends EventDispatcher<
    */
   abstract get accessGroups(): Groups
 
+  /**
+   * Query flows
+   */
+  abstract get queryFlows(): QueryFlows
+
   /**
    * Get organization members
    */

package/src/storages/queryFlows/queryFlow.impl.ts

@@ -0,0 +1,74 @@
+import {QueryFlow, QueryFlowEvent} from "./queryFlow"
+import {QueryFlowDto, QueryFlowStatus} from "../../dto/queryFlowResponse"
+import {FlowId} from "./queryFlows"
+import {Context} from "../../context"
+import {RpcService} from "../../services/rpcService"
+import {ResponseUtils} from "../../services/responseUtils"
+
+
+export class QueryFlowImpl extends QueryFlow {
+  private _content?: QueryFlowDto
+  private _id?: FlowId
+
+  constructor(private readonly context: Context) {
+    super()
+  }
+
+  async initFrom(id: FlowId) {
+    this._id = id
+    await this.fetch()
+  }
+
+  async fetch() {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/QueryFlows")
+      .searchParam("flowId", this.id)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Failed to fetch query flow with id ${this.id}`, response)
+    }
+
+    // parse flow from the server's response
+    const flow = (await response!.json()) as QueryFlowDto
+
+    const lastState = this._content?.state
+
+    this._content = flow
+    if (lastState !== undefined && lastState !== this._content.state){
+      this.dispatch({
+        type: QueryFlowEvent.UPDATED,
+        data: this
+      })
+    }
+
+    if (this._content.state === QueryFlowStatus.IN_PROGRESS) {
+      setTimeout(async () => await this.fetch(), 2000)
+    }
+  }
+
+
+  get id(): FlowId {
+    if (this._id)
+      return this._id
+    else
+      throw new Error("Query fLow is not loaded")
+  }
+
+  get resultUrl(): string {
+    if (this._content && this._content.result.fileUrl)
+      return this._content.result.fileUrl
+    else
+      throw new Error("Query fLow is not loaded")
+  }
+
+  get status(): QueryFlowStatus {
+    if (this._content)
+      return this._content.state
+    else
+      throw new Error("Query fLow is not loaded")
+  }
+
+}

package/src/storages/queryFlows/queryFlow.ts

@@ -0,0 +1,20 @@
+import {EventDispatcher} from "../../events"
+import {FlowId} from "./queryFlows"
+import {QueryFlowStatus} from "../../dto/queryFlowResponse"
+
+export enum QueryFlowEvent {
+  UPDATED = "updated"
+}
+
+export abstract class QueryFlow extends EventDispatcher<
+  QueryFlowEvent,
+  QueryFlow
+> {
+
+  abstract get id(): FlowId
+
+  abstract get status(): QueryFlowStatus
+
+  abstract get resultUrl(): string
+
+}

package/src/storages/queryFlows/queryFlows.impl.ts

@@ -0,0 +1,151 @@
+
+import {Context} from "../../context"
+import {FlowId, QueryFlows, QueryFlowsEvent} from "./queryFlows"
+import {QueryFlow} from "./queryFlow"
+import {OrganizationImpl} from "../organizations/organization.impl"
+import {RpcService} from "../../services/rpcService"
+import {ResponseUtils} from "../../services/responseUtils"
+import {WorkspaceId} from "../workspaces/workspaces"
+import {
+  QueryFlowListResponse,
+  QueryFlowResponse
+} from "../../dto/queryFlowResponse"
+import {QueryFlowImpl} from "./queryFlow.impl"
+import {FileId} from "../files/file"
+import {UploadFile} from "../files/files"
+
+
+export class QueryFlowsImpl extends QueryFlows {
+
+  private _collection: QueryFlow[] = []
+
+  constructor(
+    public readonly organization: OrganizationImpl,
+    public readonly context: Context) {
+    super()
+  }
+
+  async init() {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/QueryFlows/list")
+      .searchParam("organizationId", this.organization.id)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Failed to fetch query flows for org ${this.organization.id}`, response)
+    }
+
+    // parse flows from the server's response
+    const flows = ((await response!.json()) as QueryFlowListResponse)
+      .flowIds
+
+    // init flows from the server's response
+    for (const flow of flows) {
+      // create workspace implementation
+      const flowImpl = new QueryFlowImpl(this.context)
+
+      // init workspace from the server's response
+      await flowImpl.initFrom(flow)
+
+      // add workspace to the collection
+      this._collection.push(flowImpl)
+
+      // dispatch event
+      this.dispatch({
+        type: QueryFlowsEvent.ADDED,
+        data: flowImpl
+      })
+    }
+  }
+
+  get collection(): QueryFlow[] {
+    return this._collection
+  }
+
+  async create(workspaceId: WorkspaceId, fileId: FileId, file: UploadFile ): Promise<FlowId> {
+    if (workspaceId === undefined || workspaceId === null || workspaceId.trim() === "") {
+      throw new Error("WorkspaceId is required, must be not empty")
+    }
+    if (fileId === undefined || fileId === null || fileId.trim() === "") {
+      throw new Error("FileId is required, must be not empty")
+    }
+    if (file === undefined || file === null) {
+      throw new Error("Create query flow, file is undefined or null")
+    }
+
+    // form data to send
+    const form = new FormData()
+    form.append("organizationId", this.organization.id)
+    form.append("workspaceId", workspaceId)
+    form.append("fileId", fileId)
+    form.append("file", file, file.name)
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/QueryFlows")
+      .sendPostFormData(form)
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+
+      await ResponseUtils.throwError(`Query flow creation for ${file.name}`, response)
+    }
+
+    const content = (await response!.json()) as QueryFlowResponse
+    // create workspace implementation
+    const queryFlow = new QueryFlowImpl(this.context)
+    await queryFlow.initFrom(content.flowId)
+
+    // add workspace to the collection
+    this._collection.push(queryFlow)
+
+
+    // dispatch event
+    this.dispatch({
+      type: QueryFlowsEvent.ADDED,
+      data: queryFlow
+    })
+
+    return queryFlow.id
+  }
+
+  async delete(id: FlowId): Promise<void> {
+    const flow = this._collection.find(flow => flow.id == id)
+
+    if (!flow) {
+      throw new Error(`Query flow ${id} is not found`)
+    }
+
+    // send delete request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/QueryFlows")
+      .searchParam("flowId", id)
+      .sendDelete()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Failed to delete query flow ${id} in organization: ${this.organization.id}`,
+        response
+      )
+    }
+
+    // remove query flow from the collection
+    const index = this._collection.indexOf(flow)
+    if (index < 0) {
+      throw new Error(`Query flow ${id} is not found`)
+    }
+    this._collection.splice(index, 1)
+
+    // dispatch event
+    this.dispatch({
+      type: QueryFlowsEvent.REMOVED,
+      data: flow
+    })
+  }
+
+}

package/src/storages/queryFlows/queryFlows.ts

@@ -0,0 +1,32 @@
+import {EventDispatcher} from "../../events"
+import {QueryFlow} from "./queryFlow"
+import {WorkspaceId} from "../workspaces/workspaces"
+import {FileId} from "../files/file"
+import {UploadFile} from "../files/files"
+
+
+/**
+ * Query flow id.
+ */
+export type FlowId = string
+
+/**
+ * Query flow event.
+ */
+export enum QueryFlowsEvent {
+  ADDED = "added",
+  REMOVED = "removed"
+}
+
+export abstract class QueryFlows extends EventDispatcher<
+  QueryFlowsEvent,
+  QueryFlow
+> {
+
+  abstract get collection(): QueryFlow[]
+
+  abstract create(workspaceId: WorkspaceId, fileId: FileId, file: UploadFile ): Promise<FlowId>
+
+  abstract delete(id: FlowId): Promise<void>
+
+}

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

@@ -42,6 +42,13 @@ export class WorkspaceImpl extends Workspace {
     throw new Error("Workspace is not loaded.")
   }
 
+  get isShared(): boolean {
+    if (this._workspace) {
+      return this._workspace.isShared
+    }
+    throw new Error("Workspace is not loaded.")
+  }
+
   get files(): Files {
     return this._files
   }
@@ -115,6 +122,42 @@ export class WorkspaceImpl extends Workspace {
     })
   }
 
+  async share(isShared: boolean): Promise<void> {
+    if (!this._workspace) {
+      throw new Error("Workspace is not loaded.")
+    }
+    if (this._isMarkAsDeleted) {
+      throw new Error("Workspace is marked as deleted.")
+    }
+    if (isShared === this.isShared) {
+      return Promise.resolve()
+    }
+    if (isShared === undefined || isShared === null) {
+      throw new Error("Is shared parameter is required.")
+    }
+
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/workspaces/library")
+      .sendPutJson({
+        workspaceId: this.id,
+        isShared: isShared
+      })
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to change workspace shared state", response)
+    }
+
+    if (this._workspace) {
+      this._workspace.isShared = isShared
+    }
+
+    this.dispatch({
+      type: WorkspaceEvent.CHANGED,
+      data: this
+    })
+  }
+
   async initFrom(workspace: WorkspaceDto) {
     this._workspace = workspace
   }

package/src/storages/workspaces/workspace.ts

@@ -37,6 +37,8 @@ export abstract class Workspace extends EventDispatcher<
    */
   abstract get description(): string
 
+  abstract get isShared(): boolean
+
   /**
    * Workspace files.
    */
@@ -51,4 +53,10 @@ export abstract class Workspace extends EventDispatcher<
    * Change workspace name and description.
    */
   abstract change(name: string, description: string): Promise<void>
+
+  /**
+   * Make workspace available for the library implementation
+   * @param isShared
+   */
+  abstract share(isShared: boolean): Promise<void>
 }