@neuralinnovations/dataisland-sdk 0.0.1-dev2 → 0.0.1-dev20

package/src/dto/chatResponse.ts

@@ -0,0 +1,103 @@
+export interface SourceDto {
+  id: string;
+  name: string;
+  url: string;
+  content: string;
+  page: number;
+}
+
+export interface AnswerDto {
+  id: string;
+  chatId: string;
+  question: string;
+  context: string;
+  sources: SourceDto[];
+  timestamp: number;
+}
+
+export interface ChatDto {
+  id: string;
+  name: string;
+  createdAt: number;
+  modifiedAt: number;
+  userId: string;
+  organizationId: string;
+  workspaceId: string;
+  answers: AnswerDto[];
+}
+
+export interface ChatListResponse {
+  chats: ChatDto[]
+}
+
+export enum AnswerStatus {
+  RUNNING = 0,
+  SUCCESS = 1,
+  CANCELED = 2,
+  FAIL = 3,
+}
+
+export interface AnswerStepDto {
+  id: string;
+  type: StepType;
+  status: StepStatus;
+  start_at: string;
+  end_at: string;
+  tokens: string[];
+  sources: SourceDto[];
+}
+
+export interface FetchAnswerResponse {
+  id: string;
+  status: AnswerStatus;
+  steps: AnswerStepDto[];
+}
+
+export interface FetchTokensResponse {
+  id: string;
+  step_id: string;
+  step_status: number;
+  step_tokens: string[];
+}
+
+export interface AnswerSourcesResponse {
+  chat_uid: string;
+  uid: string;
+  step_id: string;
+  sources: SourceDto[];
+}
+
+export enum StepStatus {
+  RUNNING = 0,
+  SUCCESS = 1,
+  FAIL = 2,
+  CANCELED = 3,
+}
+
+export enum StepType {
+  PREPARE = 0,
+  SOURCES = 1,
+  GENERATE_ANSWER = 6,
+  FINALIZE_RESULT = 9,
+  DONE = 10,
+}
+
+export class StepTypeInfo {
+  public static hasTokens(type: StepType): boolean {
+    switch (type) {
+    case StepType.GENERATE_ANSWER:
+    case StepType.DONE:
+    case StepType.FINALIZE_RESULT:
+      return true
+    }
+    return false
+  }
+
+  public static hasSources(type: StepType): boolean {
+    switch (type) {
+    case StepType.SOURCES:
+      return true
+    }
+    return false
+  }
+}

package/src/dto/userInfoResponse.ts

@@ -1,3 +1,7 @@
+import { WorkspaceDto } from "./workspacesResponse"
+import { UserId } from "../storages/user/userProfile"
+import { OrganizationId } from "../storages/organizations/organizations"
+
 export interface UserInfoResponse {
   adminInOrganization: string[]
   organizations: OrganizationDto[]
@@ -5,12 +9,12 @@ export interface UserInfoResponse {
 }
 
 export interface UserDto {
-  id: string
+  id: UserId
   isDeleted: boolean
   created_at: number
   modified_at: number
   profile: ProfileDto
-  settings: UserSettings
+  settings?: UserSettings | null
 }
 
 export interface ProfileDto {
@@ -29,9 +33,17 @@ export interface OrganizationProfileDto {
 }
 
 export interface OrganizationDto {
-  id: string
+  id: OrganizationId
   createdAt: number
   modifiedAt: number
   membersCount: number
   profile: OrganizationProfileDto
 }
+
+export interface OrganizationWorkspaces extends OrganizationDto {
+  workspaces: WorkspaceDto[]
+}
+
+export interface MembersResponse {
+  members: UserDto
+}

package/src/dto/workspacesResponse.ts

@@ -0,0 +1,49 @@
+import { WorkspaceId } from "../storages/workspaces/workspaces"
+import { FileId } from "../storages/files/file"
+
+export interface WorkspaceProfileDto {
+  name: string
+  description: string
+}
+
+export interface WorkspaceDto {
+  id: WorkspaceId
+  createdAt: number
+  modifiedAt: number
+  profile: WorkspaceProfileDto
+}
+
+export interface WorkspacesResponse {
+  workspaces: WorkspaceDto[]
+}
+
+export interface FileUrlDto {
+  url: string
+}
+
+export interface FileProgressDto {
+  file_id: FileId
+  file_parts_count: number
+  completed_parts_count: number
+  success: boolean
+  error?: string
+}
+
+export interface FileDto {
+  id: string
+  createdAt: number
+  modifiedAt: number
+  name: string
+  description: string
+  url: string
+  hash: string
+  organizationId: string
+  workspaceId: string
+  isProcessedSuccessfully: boolean
+}
+
+export interface FileListResponse {
+  files: FileDto[]
+  totalFilesCount: number
+  filesPerPage: number
+}

package/src/events.ts

@@ -1,25 +1,25 @@
-import { type Disposable, DisposableContainer } from './disposable'
+import { type Disposable, DisposableContainer } from "./disposable"
 
-export interface Input<ET, DT> {
-  type?: ET
-  data: DT
+export interface Input<EventType, DataType> {
+  type?: EventType
+  data: DataType
 }
 
-export interface Event<ET, DT> extends Input<ET, DT> {
+export interface Event<EventType, DataType> extends Input<EventType, DataType> {
   unsubscribe: () => void
 }
 
-export interface EventSubscriber<ET, DT> {
-  subscribe: (callback: (event: Event<ET, DT>) => void, type?: ET) => Disposable
+export interface EventSubscriber<EventType, DataType> {
+  subscribe: (callback: (event: Event<EventType, DataType>) => void, type?: EventType) => Disposable
 }
 
-export class EventDispatcher<ET, DT> implements EventSubscriber<ET, DT> {
+export class EventDispatcher<EventType, DataType> implements EventSubscriber<EventType, DataType> {
   private _listeners: Array<{
-    callback: (value: Event<ET, DT>) => void
+    callback: (value: Event<EventType, DataType>) => void
     disposable: Disposable
   }> = []
 
-  dispatch(input: Input<ET, DT>): void {
+  dispatch(input: Input<EventType, DataType>): void {
     this._listeners.slice().forEach(it => {
       const value = {
         type: input.type,
@@ -27,16 +27,16 @@ export class EventDispatcher<ET, DT> implements EventSubscriber<ET, DT> {
         unsubscribe: () => {
           it.disposable.dispose()
         }
-      } satisfies Event<ET, DT>
+      } satisfies Event<EventType, DataType>
       it.callback(value)
     })
   }
 
-  subscribe(callback: (event: Event<ET, DT>) => void, type?: ET): Disposable {
+  subscribe(callback: (event: Event<EventType, DataType>) => void, type?: EventType): Disposable {
     const container = new DisposableContainer()
     if (type !== undefined) {
       const cb = callback
-      const listener = (evt: Event<ET, DT>): void => {
+      const listener = (evt: Event<EventType, DataType>): void => {
         if (evt.type === type) {
           cb(evt)
         }

package/src/index.ts

@@ -1,17 +1,35 @@
-import { version } from '../package.json'
-import { _createApp } from './internal/createApp.impl'
-import { type AppBuilder } from './appBuilder'
-import { type AppSdk } from './appSdk'
+import { version } from "../package.json"
+import { _createApp } from "./internal/createApp.impl"
+import { type AppBuilder } from "./appBuilder"
+import { type DataIslandApp } from "./dataIslandApp"
 
-export * from './events'
-export * from './types'
-export * from './disposable'
-export * from './types'
-export * from './credentials'
-export * from './appSdk'
+export * from "./events"
+export * from "./disposable"
+export * from "./credentials"
+export * from "./dataIslandApp"
+export * from "./appBuilder"
+export * from "./context"
+export * from "./middleware"
+export * from "./dto/chatResponse"
+export * from "./dto/accessGroupResponse"
+export * from "./dto/userInfoResponse"
+export * from "./dto/workspacesResponse"
+export * from "./storages/organizations/organizations"
+export * from "./storages/organizations/organization"
+export * from "./storages/workspaces/workspaces"
+export * from "./storages/workspaces/workspace"
+export * from "./storages/groups/groups"
+export * from "./storages/user/userProfile"
+export * from "./storages/files/files"
+export * from "./storages/files/file"
+export * from "./storages/files/filesPage"
+export * from "./storages/chats/chats"
+export * from "./storages/chats/chat"
 
-const _appsNotReady = new Map<string, Promise<AppSdk>>()
-const _appsReady = new Map<string, AppSdk>()
+// map of apps that are not ready to be used
+const _appsNotReady = new Map<string, Promise<DataIslandApp>>()
+// map of apps that are ready to be used
+const _appsReady = new Map<string, DataIslandApp>()
 
 /**
  * Current SDK version.
@@ -21,14 +39,17 @@ export const SDK_VERSION = version
 /**
  * Default DataIsland App name.
  */
-export const DEFAULT_NAME = '[DEFAULT]'
+export const DEFAULT_NAME = "[DEFAULT]"
 
 /**
  * Default DataIsland App host.
  */
-export const DEFAULT_HOST = 'https://api.dataisland.com.ua'
+export const DEFAULT_HOST = "https://api.dataisland.com.ua"
 
-export function sdks(): AppSdk[] {
+/**
+ * Returns a list of DataIsland App instances.
+ */
+export function dataIslandInstances(): DataIslandApp[] {
   return Array.from(_appsReady.values())
 }
 
@@ -39,19 +60,19 @@ export function sdks(): AppSdk[] {
  * @returns A DataIsland App instance.
  * @example
  * ```js
- * import { appSdk } from 'data-island'
+ * import { dataIslandApp, DEFAULT_NAME } from '@neuralinnovations/dataisland-sdk'
  *
- * const app = await appSdk("my-app", builder => {
+ * const app = await dataIslandApp(DEFAULT_NAME, builder => {
  *  builder.useHost("https://dataisland.com.ua")
  *  builder.useAutomaticDataCollectionEnabled(true)
  *  builder.useCredential(new BasicCredential("email", "password"))
  *  })
  * ```
  */
-export async function appSdk(
+export async function dataIslandApp(
   name?: string,
   setup?: (builder: AppBuilder) => Promise<void>
-): Promise<AppSdk> {
+): Promise<DataIslandApp> {
   name = name ?? DEFAULT_NAME
 
   let appPromise = _appsNotReady.get(name)
@@ -69,7 +90,7 @@ export async function appSdk(
   } else {
     if (setup !== undefined) {
       throw new Error(
-        `App ${name} is initializing. You can't setup the same again.`
+        `DataIsland ${name} is initializing. You can't setup the same again.`
       )
     }
   }

package/src/internal/app.impl.ts

@@ -1,27 +1,27 @@
-import { DEFAULT_HOST } from '../index'
-import { type AppBuilder } from '../appBuilder'
-import { AppBuilderImplementation } from './appBuilder.impl'
-import { type Constructor, Registry } from './registry'
-import { Context } from '../context'
-import { DisposableContainer, type Lifetime } from '../disposable'
-import { type Service, ServiceContext } from '../services/service'
-import { CredentialService } from '../services/credentialService'
-import { MiddlewareService } from '../services/middlewareService'
-import { type CredentialBase } from '../credentials'
-import { AppSdk } from '../appSdk'
-import { RpcService } from '../services/rpcService'
-import { CommandService } from '../services/commandService'
+import { DEFAULT_HOST } from "../index"
+import { type AppBuilder } from "../appBuilder"
+import { AppBuilderImplementation } from "./appBuilder.impl"
+import { type Constructor, Registry } from "./registry"
+import { Context } from "../context"
+import { DisposableContainer, type Lifetime } from "../disposable"
+import { type Service, ServiceContext } from "../services/service"
+import { CredentialService } from "../services/credentialService"
+import { MiddlewareService } from "../services/middlewareService"
+import { type CredentialBase } from "../credentials"
+import { DataIslandApp } from "../dataIslandApp"
+import { RpcService } from "../services/rpcService"
+import { CommandService } from "../services/commandService"
 import {
   StartCommandHandler,
   StartCommand
-} from '../commands/startCommandHandler'
-import { UserProfileService } from '../services/userProfileService'
-import { OrganizationService } from '../services/organizationService'
-import { Organizations } from '../storages/organizations'
-import { UserProfile } from '../storages/userProfile'
-import { isUnitTest, UnitTest } from '../unitTest'
-
-export class AppImplementation extends AppSdk {
+} from "../commands/startCommandHandler"
+import { UserProfileService } from "../services/userProfileService"
+import { OrganizationService } from "../services/organizationService"
+import { Organizations } from "../storages/organizations/organizations"
+import { UserProfile } from "../storages/user/userProfile"
+import { isUnitTest, UnitTest } from "../unitTest"
+
+export class DataIslandAppImpl extends DataIslandApp {
   readonly name: string
   private _host: string = DEFAULT_HOST
   private _automaticDataCollectionEnabled: boolean = true
@@ -104,13 +104,6 @@ export class AppImplementation extends AppSdk {
       return new OrganizationService(context)
     })
 
-    // register middlewares
-    builder.registerMiddleware(async (req, next) => {
-      req.headers.set('accept', 'text/plain')
-      req.headers.set('content-type', 'application/json')
-      return await next(req)
-    })
-
     // call customer setup
     if (setup !== undefined) {
       await setup(builder)
@@ -154,7 +147,9 @@ export class AppImplementation extends AppSdk {
     const waitList: Array<Promise<void>> = []
     // call onRegister service's callback
     services.forEach(([serviceContext]) => {
-      waitList.push(serviceContext.onRegister())
+      if (typeof serviceContext.onRegister === "function") {
+        waitList.push(serviceContext.onRegister())
+      }
     })
 
     // wait for all services to register
@@ -167,7 +162,9 @@ export class AppImplementation extends AppSdk {
     waitList.length = 0
     // call onStart service's callback
     services.forEach(([serviceContext]) => {
-      waitList.push(serviceContext.onStart())
+      if (typeof serviceContext.onStart === "function") {
+        waitList.push(serviceContext.onStart())
+      }
     })
 
     // wait for all services to start
@@ -181,7 +178,7 @@ export class AppImplementation extends AppSdk {
 
     // log app initialized
     if (!isUnitTest(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)) {
-      console.log(`AppSDK ${this.name} initialized`)
+      console.log(`DataIsland ${this.name} initialized`)
     }
   }
 }

package/src/internal/appBuilder.impl.ts

@@ -1,12 +1,12 @@
-import { AppBuilder } from '../appBuilder'
-import { DEFAULT_HOST } from '../index'
-import { type CredentialBase, DefaultCredential } from '../credentials'
-import type { Middleware } from '../middleware'
-import { type Service, type ServiceContext } from '../services/service'
-import { type Constructor } from './registry'
-import { Command, CommandHandler } from '../services/commandService'
-import { Context } from '../context'
-import { UnitTest } from '../unitTest'
+import { AppBuilder } from "../appBuilder"
+import { DEFAULT_HOST } from "../index"
+import { type CredentialBase, DefaultCredential } from "../credentials"
+import type { Middleware } from "../middleware"
+import { type Service, type ServiceContext } from "../services/service"
+import { type Constructor } from "./registry"
+import { Command, CommandHandler } from "../services/commandService"
+import { Context } from "../context"
+import { UnitTest } from "../unitTest"
 
 export class AppBuilderImplementation extends AppBuilder {
   envData: Record<string, any> = {
@@ -33,7 +33,7 @@ export class AppBuilderImplementation extends AppBuilder {
   useAutomaticDataCollectionEnabled(value: boolean): AppBuilder {
     if (value === undefined || value === null) {
       throw new Error(
-        'useAutomaticDataCollectionEnabled, value is undefined|null'
+        "useAutomaticDataCollectionEnabled, value is undefined|null"
       )
     }
     this.automaticDataCollectionEnabled = value
@@ -42,7 +42,7 @@ export class AppBuilderImplementation extends AppBuilder {
 
   useCredential(credential: CredentialBase): AppBuilder {
     if (credential === undefined || credential === null) {
-      throw new Error('useCredential, credential is undefined|null')
+      throw new Error("useCredential, credential is undefined|null")
     }
     this.credential = credential
     return this
@@ -50,7 +50,7 @@ export class AppBuilderImplementation extends AppBuilder {
 
   registerMiddleware(middleware: Middleware): AppBuilder {
     if (middleware === undefined || middleware === null) {
-      throw new Error('addMiddleware, middleware is undefined|null')
+      throw new Error("addMiddleware, middleware is undefined|null")
     }
     this.middlewares.push(middleware)
     return this
@@ -61,10 +61,10 @@ export class AppBuilderImplementation extends AppBuilder {
     factory: (context: ServiceContext) => T
   ): AppBuilder {
     if (type === undefined || type === null) {
-      throw new Error('registerService, type is undefined|null')
+      throw new Error("registerService, type is undefined|null")
     }
     if (factory === undefined || factory === null) {
-      throw new Error('registerService, factory is undefined|null')
+      throw new Error("registerService, factory is undefined|null")
     }
     this.services.push([type, factory])
     return this
@@ -75,10 +75,10 @@ export class AppBuilderImplementation extends AppBuilder {
     commandFactory: (context: Context) => CommandHandler<T>
   ): AppBuilder {
     if (messageType === undefined || messageType === null) {
-      throw new Error('registerCommand, messageType is undefined|null')
+      throw new Error("registerCommand, messageType is undefined|null")
     }
     if (commandFactory === undefined || commandFactory === null) {
-      throw new Error('registerCommand, commandFactory is undefined|null')
+      throw new Error("registerCommand, commandFactory is undefined|null")
     }
     this.commands.push([messageType, commandFactory])
     return this

package/src/internal/createApp.impl.ts

@@ -1,12 +1,12 @@
-import { AppImplementation } from './app.impl'
-import { type AppBuilder } from '../appBuilder'
-import { AppSdk } from '../appSdk'
+import { DataIslandAppImpl } from "./app.impl"
+import { type AppBuilder } from "../appBuilder"
+import { DataIslandApp } from "../dataIslandApp"
 
 export async function _createApp(
   name: string,
   setup?: (builder: AppBuilder) => Promise<void>
-): Promise<AppSdk> {
-  const app = new AppImplementation(name)
+): Promise<DataIslandApp> {
+  const app = new DataIslandAppImpl(name)
   await app.initialize(setup)
   return app
 }

package/src/internal/registry.ts

@@ -1,9 +1,21 @@
+/**
+ * Constructor type.
+ */
 export type Constructor<T> = new (...args: any[]) => T
 
+/**
+ * Provider interface.
+ */
 abstract class Provider {
+  /**
+   * Provide method.
+   */
   abstract provide(): any | undefined
 }
 
+/**
+ * MethodProvider class.
+ */
 class MethodProvider<T> extends Provider {
   private instance?: T
   private provided: boolean = false
@@ -25,6 +37,9 @@ class MethodProvider<T> extends Provider {
   }
 }
 
+/**
+ * ValueProvider class.
+ */
 class ValueProvider<T> extends Provider {
   constructor(private readonly value: T | undefined) {
     super()
@@ -35,44 +50,77 @@ class ValueProvider<T> extends Provider {
   }
 }
 
+/**
+ * RegistryItem class.
+ */
 export class RegistryItem<T> {
   constructor(
     private readonly registry: Map<Constructor<any>, Provider>,
     private readonly type: Constructor<T>
-  ) {}
+  ) {
+  }
 
+  /**
+   * As value method.
+   * @param value
+   */
   asValue(value: T): void {
     this.registry.set(this.type, new ValueProvider<T>(value))
   }
 
+  /**
+   * As provider method.
+   * @param provider
+   * @param oneTime
+   */
   asProvider<T>(provider: () => T, oneTime: boolean = false): void {
     this.registry.set(this.type, new MethodProvider<T>(provider, oneTime))
   }
 
+  /**
+   * As factory method.
+   * @param provider
+   */
   asFactory<T>(provider: () => T): void {
     this.registry.set(this.type, new MethodProvider<T>(provider, false))
   }
 
+  /**
+   * As singleton method.
+   * @param provider
+   */
   asSingleton<T>(provider: () => T): void {
     this.registry.set(this.type, new MethodProvider<T>(provider, true))
   }
 }
 
+/**
+ * Registry class.
+ */
 export class Registry {
-  private readonly services: Map<Constructor<any>, Provider>
-
-  constructor() {
-    this.services = new Map()
-  }
+  private readonly services: Map<Constructor<any>, Provider> = new Map()
 
+  /**
+   * Map method.
+   * @param type
+   */
   map<T>(type: Constructor<T>): RegistryItem<T> {
     return new RegistryItem<T>(this.services, type)
   }
 
+  /**
+   * Set method.
+   * @param type
+   * @param provider
+   */
   set<T>(type: Constructor<T>, provider: Provider): void {
     this.services.set(type, provider)
   }
 
+  /**
+   * Get method.
+   * @param type
+   */
   get<T>(type: Constructor<T>): T | undefined {
     const provider = this.services.get(type)
     if (provider === undefined) {

package/src/services/commandService.ts

@@ -1,6 +1,6 @@
-import { Service } from './service'
-import { Context } from '../context'
-import { Constructor } from '../internal/registry'
+import { Service } from "./service"
+import { Context } from "../context"
+import { Constructor } from "../internal/registry"
 
 export abstract class CommandHandler<T> {
   constructor(protected readonly context: Context) {}

package/src/services/credentialService.ts

@@ -1,6 +1,6 @@
-import { type CredentialBase } from '../credentials'
-import { Service } from './service'
-import { type DisposableContainer } from '../disposable'
+import { type CredentialBase } from "../credentials"
+import { Service } from "./service"
+import { type DisposableContainer } from "../disposable"
 
 export class CredentialService extends Service {
   private _credentialDispose?: DisposableContainer = undefined