@neuralinnovations/dataisland-sdk 0.0.1-dev1

package/src/events.ts

@@ -0,0 +1,71 @@
+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
+}
+
+export interface Event<ET, DT> extends Input<ET, DT> {
+  unsubscribe: () => void
+}
+
+export interface EventSubscriber<ET, DT> {
+  subscribe: (callback: (event: Event<ET, DT>) => void, type?: ET) => Disposable
+}
+
+export class EventDispatcher<ET, DT> implements EventSubscriber<ET, DT> {
+  private _listeners: Array<{
+    callback: (value: Event<ET, DT>) => void
+    disposable: Disposable
+  }> = []
+
+  dispatch(input: Input<ET, DT>): void {
+    this._listeners.slice().forEach(it => {
+      const value = {
+        type: input.type,
+        data: input.data,
+        unsubscribe: () => {
+          it.disposable.dispose()
+        }
+      } satisfies Event<ET, DT>
+      it.callback(value)
+    })
+  }
+
+  subscribe(callback: (event: Event<ET, DT>) => void, type?: ET): Disposable {
+    const container = new DisposableContainer()
+    if (type !== undefined) {
+      const cb = callback
+      const listener = (evt: Event<ET, DT>): void => {
+        if (evt.type === type) {
+          cb(evt)
+        }
+      }
+      const value = {
+        callback: listener,
+        disposable: container
+      }
+      container.addCallback(() => {
+        this._listeners = this._listeners.filter(it => it !== value)
+      }, this)
+
+      this._listeners.push(value)
+
+      return container
+    }
+
+    const value = {
+      callback,
+      disposable: container
+    }
+    container.addCallback(() => {
+      this._listeners = this._listeners.filter(it => it !== value)
+    }, this)
+    this._listeners.push(value)
+    return container
+  }
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+import { version } from '../package.json'
+import { _createApp } from './internal/createApp.impl'
+import { type AppBuilder } from './appBuilder'
+import { type AppSdk } from './appSdk'
+
+export * from './events'
+export * from './types'
+export * from './disposable'
+export * from './types'
+export * from './credentials'
+
+const _appsNotReady = new Map<string, Promise<AppSdk>>()
+const _appsReady = new Map<string, AppSdk>()
+
+/**
+ * Current SDK version.
+ */
+export const SDK_VERSION = version
+
+/**
+ * Default DataIsland App name.
+ */
+export const DEFAULT_NAME = '[DEFAULT]'
+
+/**
+ * Default DataIsland App host.
+ */
+export const DEFAULT_HOST = 'https://dataisland.com.ua'
+
+export function sdks(): AppSdk[] {
+  return Array.from(_appsReady.values())
+}
+
+/**
+ * Returns a DataIsland App instance.
+ * @param name Optional The name of the app.
+ * @param setup Optional setup function.
+ * @returns A DataIsland App instance.
+ * @example
+ * ```js
+ * import { appSdk } from 'data-island'
+ *
+ * const app = await appSdk("my-app", builder => {
+ *  builder.useHost("https://dataisland.com.ua")
+ *  builder.useAutomaticDataCollectionEnabled(true)
+ *  builder.useCredential(new BasicCredential("email", "password"))
+ *  })
+ * ```
+ */
+export async function appSdk(
+  name?: string,
+  setup?: (builder: AppBuilder) => Promise<void>
+): Promise<AppSdk> {
+  name = name ?? DEFAULT_NAME
+
+  let appPromise = _appsNotReady.get(name)
+  if (appPromise === undefined) {
+    appPromise = _createApp(name, setup)
+    appPromise
+      .then(app => {
+        _appsReady.set(name ?? DEFAULT_NAME, app)
+      })
+      .catch(reason => {
+        console.error(`Error: ${reason}`)
+      })
+    _appsNotReady.set(name, appPromise)
+  }
+  return await appPromise
+}

package/src/internal/app.impl.ts

@@ -0,0 +1,119 @@
+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 {
+  readonly name: string
+  private _host: string = DEFAULT_HOST
+  private _automaticDataCollectionEnabled: boolean = true
+  private readonly _registry: Registry
+  private readonly _context: Context
+  private readonly _disposable: DisposableContainer
+
+  constructor(name: string) {
+    this.name = name
+    this._registry = new Registry()
+    this._disposable = new DisposableContainer()
+    this._context = new Context(this._registry, this._disposable.lifetime)
+  }
+
+  get credential(): CredentialBase | undefined {
+    return this.resolve<CredentialService>(CredentialService)?.credential
+  }
+
+  set credential(value: CredentialBase) {
+    this.resolve(CredentialService)?.useCredential(value)
+  }
+
+  get lifetime(): Lifetime {
+    return this._disposable.lifetime
+  }
+
+  resolve = <T>(type: Constructor<T>): T | undefined => this._registry.get(type)
+
+  get automaticDataCollectionEnabled(): boolean {
+    return this._automaticDataCollectionEnabled
+  }
+
+  get host(): string {
+    return this._host
+  }
+
+  async initialize(
+    setup: ((builder: AppBuilder) => Promise<void>) | undefined
+  ): Promise<void> {
+    // create app builder
+    const builder = new AppBuilderImplementation()
+
+    // call customer setup
+    if (setup !== undefined) {
+      await setup(builder)
+    }
+
+    // host
+    this._host = builder.host
+
+    // automaticDataCollectionEnabled
+    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 => {
+      const serviceContext = new ServiceContext(
+        this._context,
+        this._disposable.defineNested()
+      )
+      serviceContext.lifetime.addCallback(() => {
+        serviceContext.onUnregister()
+      }, serviceContext)
+      const serviceInstance = serviceFactory[1](serviceContext)
+      services.push([serviceContext, serviceInstance])
+      this._registry.set(serviceFactory[0], {
+        provide: () => serviceInstance
+      })
+    })
+
+    builder.middlewares.forEach(middleware => {
+      this.resolve(MiddlewareService)?.useMiddleware(middleware)
+    })
+
+    const waitList: Array<Promise<void>> = []
+    // call onRegister service's callback
+    services.forEach(([serviceContext]) => {
+      waitList.push(serviceContext.onRegister())
+    })
+
+    await Promise.all(waitList)
+
+    waitList.length = 0
+    // call onStart service's callback
+    services.forEach(([serviceContext]) => {
+      waitList.push(serviceContext.onStart())
+    })
+
+    await Promise.all(waitList)
+
+    await Promise.resolve()
+  }
+}

package/src/internal/appBuilder.impl.ts

@@ -0,0 +1,59 @@
+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'
+
+export class AppBuilderImplementation extends AppBuilder {
+  host: string = DEFAULT_HOST
+  automaticDataCollectionEnabled: boolean = true
+  credential: CredentialBase = new DefaultCredential()
+  middlewares: Middleware[] = []
+  services: Array<[Constructor<any>, (context: ServiceContext) => Service]> = []
+
+  useHost(host: string): AppBuilder {
+    this.host = host ?? DEFAULT_HOST
+    return this
+  }
+
+  useAutomaticDataCollectionEnabled(value: boolean): AppBuilder {
+    if (value === undefined || value === null) {
+      throw new Error(
+        'useAutomaticDataCollectionEnabled, value is undefined|null'
+      )
+    }
+    this.automaticDataCollectionEnabled = value
+    return this
+  }
+
+  useCredential(credential: CredentialBase): AppBuilder {
+    if (credential === undefined || credential === null) {
+      throw new Error('useCredential, credential is undefined|null')
+    }
+    this.credential = credential
+    return this
+  }
+
+  addMiddleware(middleware: Middleware): AppBuilder {
+    if (middleware === undefined || middleware === null) {
+      throw new Error('addMiddleware, middleware is undefined|null')
+    }
+    this.middlewares.push(middleware)
+    return this
+  }
+
+  registerService<T extends Service>(
+    type: Constructor<T>,
+    factory: (context: ServiceContext) => T
+  ): AppBuilder {
+    if (type === undefined || type === null) {
+      throw new Error('registerService, type is undefined|null')
+    }
+    if (factory === undefined || factory === null) {
+      throw new Error('registerService, factory is undefined|null')
+    }
+    this.services.push([type, factory])
+    return this
+  }
+}

package/src/internal/context.ts

@@ -0,0 +1,13 @@
+import { type Constructor, type Registry } from './registry'
+import { type Lifetime } from '../disposable'
+
+export class Context {
+  constructor(
+    private readonly registry: Registry,
+    public readonly lifetime: Lifetime
+  ) {}
+
+  resolve<T>(type: Constructor<T>): T | undefined {
+    return this.registry.get(type)
+  }
+}

package/src/internal/createApp.impl.ts

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

package/src/internal/registry.ts

@@ -0,0 +1,83 @@
+export type Constructor<T> = new (...args: any[]) => T
+
+abstract class Provider {
+  abstract provide(): any | undefined
+}
+
+class MethodProvider<T> extends Provider {
+  private instance?: T
+  private provided: boolean = false
+
+  constructor(
+    private readonly provider: () => T,
+    private readonly providerOnce: boolean = false
+  ) {
+    super()
+  }
+
+  provide(): T | undefined {
+    if (this.providerOnce && this.provided) {
+      return this.instance
+    }
+    this.provided = true
+    this.instance = this.provider()
+    return this.instance
+  }
+}
+
+class ValueProvider<T> extends Provider {
+  constructor(private readonly value: T | undefined) {
+    super()
+  }
+
+  provide(): T | undefined {
+    return this.value
+  }
+}
+
+export class RegistryItem<T> {
+  constructor(
+    private readonly registry: Map<Constructor<any>, Provider>,
+    private readonly type: Constructor<T>
+  ) {}
+
+  asValue(value: T): void {
+    this.registry.set(this.type, new ValueProvider<T>(value))
+  }
+
+  asProvider<T>(provider: () => T, oneTime: boolean = false): void {
+    this.registry.set(this.type, new MethodProvider<T>(provider, oneTime))
+  }
+
+  asFactory<T>(provider: () => T): void {
+    this.registry.set(this.type, new MethodProvider<T>(provider, false))
+  }
+
+  asSingleton<T>(provider: () => T): void {
+    this.registry.set(this.type, new MethodProvider<T>(provider, true))
+  }
+}
+
+export class Registry {
+  private readonly services: Map<Constructor<any>, Provider>
+
+  constructor() {
+    this.services = new Map()
+  }
+
+  map<T>(type: Constructor<T>): RegistryItem<T> {
+    return new RegistryItem<T>(this.services, type)
+  }
+
+  set<T>(type: Constructor<T>, provider: Provider): void {
+    this.services.set(type, provider)
+  }
+
+  get<T>(type: Constructor<T>): T | undefined {
+    const provider = this.services.get(type)
+    if (provider === undefined) {
+      return undefined
+    }
+    return provider.provide()
+  }
+}

package/src/middleware.ts

@@ -0,0 +1,7 @@
+/**
+ * DataIsland App request middleware.
+ */
+export type Middleware = (
+  req: Request,
+  next: (req: Request) => Promise<Response>
+) => Promise<void>

package/src/services/credentialService.ts

@@ -0,0 +1,24 @@
+import { type CredentialBase } from '../credentials'
+import { Service } from './service'
+import { type DisposableContainer } from '../disposable'
+
+export class CredentialService extends Service {
+  private _credentialDispose?: DisposableContainer = undefined
+  private _credential?: CredentialBase = undefined
+
+  public get credential(): CredentialBase | undefined {
+    return this._credential
+  }
+
+  useCredential(credential: CredentialBase): void {
+    if (credential !== this._credential) {
+      if (this._credentialDispose !== undefined) {
+        this._credentialDispose.dispose()
+      }
+      this._credentialDispose = this.lifetime.defineNested()
+      this._credential = credential
+
+      credential.onRegister(this._credentialDispose.lifetime, this.context)
+    }
+  }
+}

package/src/services/middlewareService.ts

@@ -0,0 +1,33 @@
+import { Service } from './service'
+import { type Middleware } from '../middleware'
+import { type Disposable } from '../disposable'
+
+export class MiddlewareService extends Service {
+  _middlewares: Middleware[] = []
+
+  public useMiddleware(middleware: Middleware): Disposable {
+    this._middlewares.push(middleware)
+    const result = this.lifetime.defineNested()
+    result.addCallback(() => {
+      this._middlewares = this._middlewares.filter(m => m !== middleware)
+    }, this)
+    return result
+  }
+
+  public async process(
+    req: Request,
+    next: (req: Request) => Promise<Response>
+  ): Promise<Response> {
+    const middlewares = this._middlewares.slice()
+    let index = -1
+
+    const processNext = async (request: Request): Promise<Response> => {
+      index++
+      if (index < middlewares.length) {
+        await middlewares[index](request, processNext)
+      }
+      return await next(request)
+    }
+    return await processNext(req)
+  }
+}

package/src/services/rpcService.ts

@@ -0,0 +1,72 @@
+import { Service, type ServiceContext } from './service'
+import { MiddlewareService } from './middlewareService'
+
+export class RpcService extends Service {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async request(req: Request): Promise<Response> {
+    throw new Error('Not implemented')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  buildUrl(path: string): string {
+    throw new Error('Not implemented')
+  }
+
+  async get(path: string): Promise<Response> {
+    return await this.request(
+      new Request(this.buildUrl(path), {
+        method: 'GET'
+      })
+    )
+  }
+
+  async post(path: string, body?: BodyInit | null): Promise<Response> {
+    return await this.request(
+      new Request(this.buildUrl(path), {
+        method: 'POST',
+        body
+      })
+    )
+  }
+
+  async put(path: string, body?: BodyInit | null): Promise<Response> {
+    return await this.request(
+      new Request(this.buildUrl(path), {
+        method: 'PUT',
+        body
+      })
+    )
+  }
+
+  async delete(path: string): Promise<Response> {
+    return await this.request(
+      new Request(this.buildUrl(path), {
+        method: 'DELETE'
+      })
+    )
+  }
+}
+
+export class RpcServiceImpl extends RpcService {
+  constructor(serviceContext: ServiceContext, public readonly host: string) {
+    super(serviceContext)
+  }
+
+  override async request(req: Request): Promise<Response> {
+    const middlewareService = this.resolve(MiddlewareService)
+    if (middlewareService !== undefined) {
+      return await middlewareService.process(req, async req => {
+        return await fetch(req)
+      })
+    } else {
+      return await fetch(req)
+    }
+  }
+
+  override buildUrl(path: string): string {
+    if (this.host.endsWith('/') && path.startsWith('/')) {
+      return `${this.host}${path.slice(1)}`
+    }
+    return `${this.host}${path}`
+  }
+}

package/src/services/service.ts

@@ -0,0 +1,46 @@
+import { type Context } from '../internal/context'
+import { type Constructor } from '../internal/registry'
+import { type DisposableContainer, type Lifetime } from '../disposable'
+
+export class ServiceContext {
+  constructor(
+    public readonly context: Context,
+    private readonly disposableContainer: DisposableContainer
+  ) {}
+
+  public get lifetime(): Lifetime {
+    return this.disposableContainer.lifetime
+  }
+
+  resolve<T>(type: Constructor<T>): T | undefined {
+    return this.context.resolve(type)
+  }
+
+  public async onRegister(): Promise<void> {
+    await Promise.resolve()
+  }
+
+  public async onStart(): Promise<void> {
+    await Promise.resolve()
+  }
+
+  public onUnregister(): void {
+    // do nothing
+  }
+}
+
+export abstract class Service {
+  public resolve<T>(type: Constructor<T>): T | undefined {
+    return this.serviceContext.resolve(type)
+  }
+
+  public get lifetime(): Lifetime {
+    return this.serviceContext.lifetime
+  }
+
+  public get context(): Context {
+    return this.serviceContext.context
+  }
+
+  public constructor(private readonly serviceContext: ServiceContext) {}
+}