@neuralinnovations/dataisland-sdk 0.0.1-dev1 → 0.0.1-dev10

package/src/dto/userInfoResponse.ts

@@ -0,0 +1,47 @@
+import { WorkspaceDto } from "./workspacesResponse"
+
+export interface UserInfoResponse {
+  adminInOrganization: string[]
+  organizations: OrganizationDto[]
+  user: UserDto
+}
+
+export interface UserDto {
+  id: string
+  isDeleted: boolean
+  created_at: number
+  modified_at: number
+  profile: ProfileDto
+  settings?: UserSettings | null
+}
+
+export interface ProfileDto {
+  name: string
+  email: string
+}
+
+export interface UserSettings {
+  activeOrganizationId: string
+  activeWorkspaceId: string
+}
+
+export interface OrganizationProfileDto {
+  name: string
+  description: string
+}
+
+export interface OrganizationDto {
+  id: string
+  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,29 +1,25 @@
-import { type Disposable, DisposableContainer } from './disposable'
+import { type Disposable, DisposableContainer } from "./disposable"
 
-export interface Events<TE, TD> {
-  get events(): EventDispatcher<TE, TD>
+export interface Input<EventType, DataType> {
+  type?: EventType
+  data: DataType
 }
 
-export interface Input<ET, DT> {
-  type?: ET
-  data: DT
-}
-
-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,
@@ -31,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,16 +1,29 @@
-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 "./events"
+export * from "./disposable"
+export * from "./credentials"
+export * from "./dataIslandApp"
+export * from "./appBuilder"
+export * from "./context"
+export * from "./middleware"
+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>()
+const _appsNotReady = new Map<string, Promise<DataIslandApp>>()
+const _appsReady = new Map<string, DataIslandApp>()
 
 /**
  * Current SDK version.
@@ -20,14 +33,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://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())
 }
 
@@ -38,19 +54,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)
@@ -62,8 +78,18 @@ export async function appSdk(
       })
       .catch(reason => {
         console.error(`Error: ${reason}`)
+        _appsNotReady.delete(name ?? DEFAULT_NAME)
       })
     _appsNotReady.set(name, appPromise)
+  } else {
+    if (setup !== undefined) {
+      throw new Error(
+        `DataIsland ${name} is initializing. You can't setup the same again.`
+      )
+    }
   }
   return await appPromise
 }
+
+export { File } from "./storages/files/file"
+export { FilesPage } from "./storages/files/filesPage"

package/src/internal/app.impl.ts

@@ -1,17 +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 { type AppSdk } from '../appSdk'
-import { RpcService, RpcServiceImpl } from '../services/rpcService'
-
-export class AppImplementation implements AppSdk {
+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/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
@@ -20,10 +30,17 @@ export class AppImplementation implements AppSdk {
   private readonly _disposable: DisposableContainer
 
   constructor(name: string) {
+    super()
     this.name = name
     this._registry = new Registry()
     this._disposable = new DisposableContainer()
-    this._context = new Context(this._registry, this._disposable.lifetime)
+    this._context = new Context(this._registry, this._disposable.lifetime, name)
+
+    this._registry.map(Context).asValue(this._context)
+  }
+
+  get context(): Context {
+    return this._context
   }
 
   get credential(): CredentialBase | undefined {
@@ -48,12 +65,45 @@ export class AppImplementation implements AppSdk {
     return this._host
   }
 
+  get organizations(): Organizations {
+    return this.resolve(OrganizationService)?.organizations as Organizations
+  }
+
+  get userProfile(): UserProfile {
+    return this.resolve(UserProfileService)?.userProfile as UserProfile
+  }
+
   async initialize(
     setup: ((builder: AppBuilder) => Promise<void>) | undefined
   ): Promise<void> {
     // create app builder
     const builder = new AppBuilderImplementation()
 
+    // register commands
+    builder.registerCommand(StartCommand, (context: Context) => {
+      return new StartCommandHandler(context)
+    })
+
+    // register services
+    builder.registerService(CredentialService, (context: ServiceContext) => {
+      return new CredentialService(context)
+    })
+    builder.registerService(MiddlewareService, (context: ServiceContext) => {
+      return new MiddlewareService(context)
+    })
+    builder.registerService(RpcService, (context: ServiceContext) => {
+      return new RpcService(context, builder.host)
+    })
+    builder.registerService(CommandService, (context: ServiceContext) => {
+      return new CommandService(context)
+    })
+    builder.registerService(UserProfileService, (context: ServiceContext) => {
+      return new UserProfileService(context)
+    })
+    builder.registerService(OrganizationService, (context: ServiceContext) => {
+      return new OrganizationService(context)
+    })
+
     // call customer setup
     if (setup !== undefined) {
       await setup(builder)
@@ -66,17 +116,6 @@ export class AppImplementation implements AppSdk {
     this._automaticDataCollectionEnabled =
       builder.automaticDataCollectionEnabled
 
-    // register services
-    builder.registerService(CredentialService, (context: ServiceContext) => {
-      return new CredentialService(context)
-    })
-    builder.registerService(MiddlewareService, (context: ServiceContext) => {
-      return new MiddlewareService(context)
-    })
-    builder.registerService(RpcService, (context: ServiceContext) => {
-      return new RpcServiceImpl(context, builder.host) as RpcService
-    })
-
     // register services
     const services: Array<[ServiceContext, Service]> = []
     builder.services.forEach(serviceFactory => {
@@ -89,31 +128,57 @@ export class AppImplementation implements AppSdk {
       }, serviceContext)
       const serviceInstance = serviceFactory[1](serviceContext)
       services.push([serviceContext, serviceInstance])
-      this._registry.set(serviceFactory[0], {
-        provide: () => serviceInstance
-      })
+      this._registry.map(serviceFactory[0]).asValue(serviceInstance)
     })
 
     builder.middlewares.forEach(middleware => {
       this.resolve(MiddlewareService)?.useMiddleware(middleware)
     })
 
+    builder.commands.forEach(command => {
+      this.resolve(CommandService)?.register(command[0], command[1])
+    })
+
+    this.credential = builder.credential
+
+    //-------------------------------------------------------------------------
+    // register services
+    //-------------------------------------------------------------------------
     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
     await Promise.all(waitList)
+    //-------------------------------------------------------------------------
 
+    //-------------------------------------------------------------------------
+    // start services
+    //-------------------------------------------------------------------------
     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
     await Promise.all(waitList)
+    //-------------------------------------------------------------------------
+
+    // start app, execute start command
+    if (!isUnitTest(UnitTest.DO_NOT_START)) {
+      await this.context.execute(new StartCommand())
+    }
 
-    await Promise.resolve()
+    // log app initialized
+    if (!isUnitTest(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)) {
+      console.log(`DataIsland ${this.name} initialized`)
+    }
   }
 }

package/src/internal/appBuilder.impl.ts

@@ -1,16 +1,29 @@
-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 { 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> = {
+    unitTest: UnitTest.DO_NOTHING
+  }
   host: string = DEFAULT_HOST
   automaticDataCollectionEnabled: boolean = true
   credential: CredentialBase = new DefaultCredential()
   middlewares: Middleware[] = []
   services: Array<[Constructor<any>, (context: ServiceContext) => Service]> = []
+  commands: Array<
+    [Constructor<any>, (context: Context) => CommandHandler<any>]
+  > = []
+
+  get env(): Record<string, any> {
+    return this.envData
+  }
 
   useHost(host: string): AppBuilder {
     this.host = host ?? DEFAULT_HOST
@@ -20,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
@@ -29,15 +42,15 @@ 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
   }
 
-  addMiddleware(middleware: Middleware): 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
@@ -48,12 +61,26 @@ 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
   }
+
+  registerCommand<T extends Command>(
+    messageType: Constructor<T>,
+    commandFactory: (context: Context) => CommandHandler<T>
+  ): AppBuilder {
+    if (messageType === undefined || messageType === null) {
+      throw new Error("registerCommand, messageType is undefined|null")
+    }
+    if (commandFactory === undefined || commandFactory === 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/middleware.ts

@@ -4,4 +4,4 @@
 export type Middleware = (
   req: Request,
   next: (req: Request) => Promise<Response>
-) => Promise<void>
+) => Promise<Response>

package/src/services/commandService.ts

@@ -0,0 +1,44 @@
+import { Service } from "./service"
+import { Context } from "../context"
+import { Constructor } from "../internal/registry"
+
+export abstract class CommandHandler<T> {
+  constructor(protected readonly context: Context) {}
+
+  resolve<T>(type: Constructor<T>): T | undefined {
+    return this.context.resolve<T>(type)
+  }
+
+  abstract execute(message: T): Promise<void>
+}
+
+export abstract class Command {}
+
+export class CommandService extends Service {
+  private readonly _registry: Map<
+    Constructor<any>,
+    (context: Context) => CommandHandler<any>
+  > = new Map()
+  private _lastPromise: Promise<void> = Promise.resolve()
+
+  register<T extends Command>(
+    messageType: Constructor<T>,
+    commandFactory: (context: Context) => CommandHandler<T>
+  ): void {
+    this._registry.set(messageType, commandFactory)
+  }
+
+  async execute<T extends Command>(message: T): Promise<void> {
+    const commandFactory = this._registry.get((message as any).constructor)
+    if (commandFactory) {
+      const command = commandFactory(this.context)
+      await this._lastPromise
+      this._lastPromise = command.execute(message)
+      await this._lastPromise
+    } else {
+      throw new Error(
+        `Command not found for message type ${message.constructor.name}`
+      )
+    }
+  }
+}

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

package/src/services/middlewareService.ts

@@ -1,9 +1,9 @@
-import { Service } from './service'
-import { type Middleware } from '../middleware'
-import { type Disposable } from '../disposable'
+import { Service } from "./service"
+import { type Middleware } from "../middleware"
+import { type Disposable } from "../disposable"
 
 export class MiddlewareService extends Service {
-  _middlewares: Middleware[] = []
+  private _middlewares: Middleware[] = []
 
   public useMiddleware(middleware: Middleware): Disposable {
     this._middlewares.push(middleware)
@@ -24,10 +24,12 @@ export class MiddlewareService extends Service {
     const processNext = async (request: Request): Promise<Response> => {
       index++
       if (index < middlewares.length) {
-        await middlewares[index](request, processNext)
+        return await middlewares[index](request, processNext)
+      } else {
+        return await next(request)
       }
-      return await next(request)
     }
+
     return await processNext(req)
   }
 }