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

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 { 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

@@ -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,6 +1,6 @@
-import { AppImplementation } from './app.impl'
-import { type AppBuilder } from '../appBuilder'
-import { AppSdk } from '../appSdk'
+import { AppImplementation } from "./app.impl"
+import { type AppBuilder } from "../appBuilder"
+import { AppSdk } from "../appSdk"
 
 export async function _createApp(
   name: string,

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,6 +1,6 @@
-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[] = []
@@ -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/organizationService.ts

@@ -0,0 +1,28 @@
+import { Service } from "./service"
+import { Organizations } from "../storages/organizations"
+import { OrganizationDto, UserSettings } from "../dto/userInfoResponse"
+import { OrganizationsImpl } from "../storages/organizations.impl"
+
+export class OrganizationService extends Service {
+  private _impl?: OrganizationsImpl
+
+  private get impl(): OrganizationsImpl {
+    return this._impl ?? (this._impl = new OrganizationsImpl(this.context))
+  }
+
+  get organizations(): Organizations {
+    return this.impl
+  }
+
+  async initFrom(
+    adminInOrganization: string[],
+    organizations: OrganizationDto[],
+    settings?: UserSettings | null
+  ): Promise<void> {
+    await this.impl.internalInitFrom(
+      adminInOrganization,
+      organizations,
+      settings
+    )
+  }
+}

package/src/services/requestBuilder.ts

@@ -0,0 +1,102 @@
+export class RequestBuilder {
+  private readonly _headers: Headers
+  private readonly _searchParams: URLSearchParams
+
+  constructor(
+    private readonly _url: URL,
+    private readonly _request: (req: Request) => Promise<Response>
+  ) {
+    this._headers = new Headers()
+    this._searchParams = new URLSearchParams()
+  }
+
+  public header(name: string, value: string): RequestBuilder {
+    this._headers.set(name, value)
+    return this
+  }
+
+  public headers(
+    headers?: [string, string][] | Record<string, string> | Headers
+  ): RequestBuilder {
+    if (headers === undefined) {
+      return this
+    }
+    if (headers instanceof Headers) {
+      headers.forEach((value, name) => {
+        this._headers.set(name, value)
+      })
+    } else {
+      Object.entries(headers).forEach(([name, value]) => {
+        this._headers.set(name, value)
+      })
+    }
+    return this
+  }
+
+  public searchParam(name: string, value: string): RequestBuilder {
+    this._searchParams.set(name, value)
+    return this
+  }
+
+  public searchParams(searchParams?: Map<string, string>): RequestBuilder {
+    if (searchParams === undefined) {
+      return this
+    }
+    searchParams.forEach((value, name) => {
+      this._searchParams.set(name, value)
+    })
+    return this
+  }
+
+  public async sendPost(body?: BodyInit | null | object): Promise<Response> {
+    const url = this._url
+    url.search = this._searchParams.toString()
+    if (body !== undefined && body !== null && typeof body === "object") {
+      body = JSON.stringify(body)
+    }
+    return await this._request(
+      new Request(url, {
+        method: "POST",
+        headers: this._headers,
+        body
+      })
+    )
+  }
+
+  public async sendGet(): Promise<Response> {
+    const url = this._url
+    url.search = this._searchParams.toString()
+    return await this._request(
+      new Request(url, {
+        method: "GET",
+        headers: this._headers
+      })
+    )
+  }
+
+  public async sendDelete(): Promise<Response> {
+    const url = this._url
+    url.search = this._searchParams.toString()
+    return await this._request(
+      new Request(url, {
+        method: "DELETE",
+        headers: this._headers
+      })
+    )
+  }
+
+  public async sendPut(body?: BodyInit | null | object): Promise<Response> {
+    const url = this._url
+    url.search = this._searchParams.toString()
+    if (body !== undefined && body !== null && typeof body === "object") {
+      body = JSON.stringify(body)
+    }
+    return await this._request(
+      new Request(url, {
+        method: "PUT",
+        headers: this._headers,
+        body
+      })
+    )
+  }
+}

package/src/services/responseUtils.ts

@@ -0,0 +1,32 @@
+export class ResponseUtils {
+  public static isOk(response?: Response | null): boolean {
+    return response !== undefined && response !== null && response.ok
+  }
+
+  public static isFail(response?: Response | null): boolean {
+    return !ResponseUtils.isOk(response)
+  }
+
+  public static async throwError(
+    message: string,
+    response: Response | undefined | null
+  ): Promise<void> {
+    if (response === undefined) {
+      throw new Error(`${message}. Response is undefined`)
+    }
+    if (response === null) {
+      throw new Error(`${message}. Response is null`)
+    }
+    let errorBody: string = ""
+    if (response) {
+      try {
+        errorBody = (await response.text()) ?? ""
+      } catch (e) {
+        console.error(e)
+      }
+    }
+    throw new Error(
+      `${message}. Response fail. Status: ${response?.status},${response?.statusText}, body: ${errorBody}`
+    )
+  }
+}