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

package/jest.config.ts

@@ -3,7 +3,7 @@
  * https://jestjs.io/docs/configuration
  */
 
-import type {Config} from 'jest';
+import type { Config } from 'jest'
 
 const config: Config = {
   // All imported modules in your tests should be mocked automatically
@@ -25,7 +25,7 @@ const config: Config = {
   // collectCoverageFrom: undefined,
 
   // The directory where Jest should output its coverage files
-  coverageDirectory: "coverage",
+  coverageDirectory: 'coverage',
 
   // An array of regexp pattern strings used to skip coverage collection
   // coveragePathIgnorePatterns: [
@@ -134,7 +134,7 @@ const config: Config = {
   // runner: "jest-runner",
 
   // The paths to modules that run some code to configure or set up the testing environment before each test
-  // setupFiles: [],
+  setupFiles: ['./jest.setup.ts']
 
   // A list of paths to modules that run some code to configure or set up the testing framework before each test
   // setupFilesAfterEnv: [],
@@ -194,6 +194,6 @@ const config: Config = {
 
   // Whether to use watchman for file crawling
   // watchman: true,
-};
+}
 
-export default config;
+export default config

package/jest.setup.ts

@@ -0,0 +1,2 @@
+import * as dotenv from 'dotenv'
+dotenv.config({ path: '.env.test' })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralinnovations/dataisland-sdk",
-  "version": "0.0.1-dev1",
+  "version": "0.0.1-dev2",
   "description": "SDK for DataIsland project",
   "licenses": [
     {
@@ -55,6 +55,7 @@
     "yargs": "17.7.2"
   },
   "dependencies": {
+    "dotenv": "^16.3.2",
     "jsdom": "^23.2.0"
   }
 }

package/src/appBuilder.ts

@@ -2,15 +2,22 @@ import type { Middleware } from './middleware'
 import type { CredentialBase } from './credentials'
 import type { Service, ServiceContext } from './services/service'
 import type { Constructor } from './internal/registry'
+import { CommandHandler, Command } from './services/commandService'
+import { Context } from './context'
 
 /**
  * DataIsland App builder.
  */
 export abstract class AppBuilder {
+  /**
+   * Set custom data.
+   */
+  abstract get env(): Record<string, any>
+
   /**
    * Add a middleware to the app.
    */
-  abstract addMiddleware(middleware: Middleware): AppBuilder
+  abstract registerMiddleware(middleware: Middleware): AppBuilder
 
   /**
    * Host of the app.
@@ -36,4 +43,16 @@ export abstract class AppBuilder {
     type: Constructor<T>,
     factory: (context: ServiceContext) => T
   ): AppBuilder
+
+  /**
+   * Register a command to the app.
+   * @param messageType
+   * @param commandFactory
+   */
+  abstract registerCommand<T extends Command>(
+    messageType: Constructor<T>,
+    commandFactory:
+      | ((context: Context) => CommandHandler<T>)
+      | ((context: Context) => (context: Context) => Promise<void>)
+  ): AppBuilder
 }

package/src/appSdk.ts

@@ -1,40 +1,59 @@
 import type { Lifetime } from './disposable'
 import type { CredentialBase } from './credentials'
+import { Context } from './context'
 import type { Constructor } from './internal/registry'
+import { Organizations } from './storages/organizations'
+import { UserProfile } from './storages/userProfile'
 
 /**
  * DataIsland App instance.
  */
-export interface AppSdk {
+export abstract class AppSdk {
   /**
    * The name of this app.
    */
-  get name(): string
+  abstract get name(): string
 
   /**
    * The host of this app.
    */
-  get host(): string
+  abstract get host(): string
 
   /**
    * The automaticDataCollectionEnabled of this app.
    */
-  get automaticDataCollectionEnabled(): boolean
+  abstract get automaticDataCollectionEnabled(): boolean
 
   /**
    * The lifetime of this app.
    */
-  get lifetime(): Lifetime
+  abstract get lifetime(): Lifetime
 
   /**
    * The credential of this app.
    */
-  get credential(): CredentialBase | undefined
+  abstract get credential(): CredentialBase | undefined
 
-  set credential(value: CredentialBase)
+  abstract set credential(value: CredentialBase)
 
   /**
-   * Gets the service registered with the given type.
+   * The context of this app.
    */
-  resolve: <T>(type: Constructor<T>) => T | undefined
+  abstract get context(): Context
+
+  /**
+   * User's organizations.
+   */
+  abstract get organizations(): Organizations
+
+  /**
+   * User's profile.
+   */
+  abstract get userProfile(): UserProfile
+
+  /**
+   * Resolve a service from the app.
+   * @param type
+   */
+  abstract resolve<T>(type: Constructor<T>): T | undefined
 }

package/src/commands/startCommandHandler.ts

@@ -0,0 +1,14 @@
+import { CommandHandler, Command } from '../services/commandService'
+import { UserProfileService } from '../services/userProfileService'
+
+export class StartCommand extends Command {}
+
+export class StartCommandHandler extends CommandHandler<StartCommand> {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async execute(message: StartCommand): Promise<void> {
+    const service = this.context.resolve(
+      UserProfileService
+    ) as UserProfileService
+    await service.fetch()
+  }
+}

package/src/context.ts

@@ -0,0 +1,31 @@
+import { type Constructor, type Registry } from './internal/registry'
+import { type Lifetime } from './disposable'
+import { Command, CommandService } from './services/commandService'
+
+/**
+ * DataIsland App context.
+ */
+export class Context {
+  constructor(
+    private readonly registry: Registry,
+    public readonly lifetime: Lifetime,
+    public readonly appName: string
+  ) {}
+
+  /**
+   * Resolve a service from the context.
+   * @param type of the service
+   */
+  resolve<T>(type: Constructor<T>): T | undefined {
+    return this.registry.get(type)
+  }
+
+  /**
+   * Execute a command.
+   * @param command to execute
+   */
+  async execute<T extends Command>(command: T): Promise<void> {
+    const service = this.resolve(CommandService) as CommandService
+    await service.execute(command)
+  }
+}

package/src/credentials.ts

@@ -1,6 +1,6 @@
 import { MiddlewareService } from './services/middlewareService'
 import { type Lifetime } from './disposable'
-import { type Context } from './internal/context'
+import { type Context } from './context'
 
 /**
  * DataIsland App credential.
@@ -34,7 +34,7 @@ export class BasicCredential extends CredentialBase {
     lifetime.add(
       service.useMiddleware(async (req, next) => {
         req.headers.set('Authorization', `Basic ${this.email}:${this.password}`)
-        await next(req)
+        return await next(req)
       })
     )
   }
@@ -56,7 +56,7 @@ export class BearerCredential extends CredentialBase {
     lifetime.add(
       service.useMiddleware(async (req, next) => {
         req.headers.set('Authorization', `Bearer ${this.token}`)
-        await next(req)
+        return await next(req)
       })
     )
   }

package/src/disposable.ts

@@ -2,7 +2,7 @@
  * Represents an object that can be disposed.
  */
 export interface Disposable {
-  dispose: () => void
+  dispose(): void
 }
 
 /**

package/src/dto/userInfoResponse.ts

@@ -0,0 +1,37 @@
+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
+}
+
+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
+}

package/src/events.ts

@@ -1,9 +1,5 @@
 import { type Disposable, DisposableContainer } from './disposable'
 
-export interface Events<TE, TD> {
-  get events(): EventDispatcher<TE, TD>
-}
-
 export interface Input<ET, DT> {
   type?: ET
   data: DT

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './types'
 export * from './disposable'
 export * from './types'
 export * from './credentials'
+export * from './appSdk'
 
 const _appsNotReady = new Map<string, Promise<AppSdk>>()
 const _appsReady = new Map<string, AppSdk>()
@@ -25,7 +26,7 @@ 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[] {
   return Array.from(_appsReady.values())
@@ -62,8 +63,15 @@ 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(
+        `App ${name} is initializing. You can't setup the same again.`
+      )
+    }
   }
   return await appPromise
 }

package/src/internal/app.impl.ts

@@ -2,16 +2,26 @@ 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 { 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 { AppSdk } from '../appSdk'
+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 {
   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,52 @@ 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)
+    })
+
+    // 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)
@@ -66,17 +123,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 +135,53 @@ 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())
     })
 
+    // 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())
     })
 
+    // wait for all services to start
     await Promise.all(waitList)
+    //-------------------------------------------------------------------------
 
-    await Promise.resolve()
+    // start app, execute start command
+    if (!isUnitTest(UnitTest.DO_NOT_START)) {
+      await this.context.execute(new StartCommand())
+    }
+
+    // log app initialized
+    if (!isUnitTest(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)) {
+      console.log(`AppSDK ${this.name} initialized`)
+    }
   }
 }

package/src/internal/appBuilder.impl.ts

@@ -4,13 +4,26 @@ 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
@@ -35,7 +48,7 @@ export class AppBuilderImplementation extends AppBuilder {
     return this
   }
 
-  addMiddleware(middleware: Middleware): AppBuilder {
+  registerMiddleware(middleware: Middleware): AppBuilder {
     if (middleware === undefined || middleware === null) {
       throw new Error('addMiddleware, middleware is undefined|null')
     }
@@ -56,4 +69,18 @@ export class AppBuilderImplementation extends AppBuilder {
     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/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/middlewareService.ts

@@ -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)
   }
 }

package/src/services/organizationImpl.ts

@@ -0,0 +1,51 @@
+import { Organization, OrganizationId } from '../storages/organizations'
+import { Disposable } from '../disposable'
+import { OrganizationDto } from '../dto/userInfoResponse'
+import { OrganizationService } from './organizationService'
+import { OrganizationsImpl } from './organizationsImpl'
+
+export class OrganizationImpl extends Organization implements Disposable {
+  private _isDisposed: boolean = false
+  private _isAdmin: boolean = false
+  private _content?: OrganizationDto
+
+  constructor(
+    private readonly service: OrganizationService,
+    private readonly organizations: OrganizationsImpl
+  ) {
+    super()
+  }
+
+  get isAdmin(): boolean {
+    return this._isAdmin
+  }
+
+  get isDisposed(): boolean {
+    return this._isDisposed
+  }
+
+  dispose(): void {
+    this._isDisposed = true
+  }
+
+  public initFrom(
+    content: OrganizationDto,
+    isAdmin: boolean
+  ): OrganizationImpl {
+    this._content = content
+    this._isAdmin = isAdmin
+    return this
+  }
+
+  get id(): OrganizationId {
+    return <OrganizationId>this._content?.id
+  }
+
+  get name(): string {
+    return <OrganizationId>this._content?.profile.name
+  }
+
+  get description(): string {
+    return <OrganizationId>this._content?.profile.description
+  }
+}