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

package/src/events.ts

@@ -1,25 +1,25 @@
 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,15 +1,47 @@
 import { version } from "../package.json"
 import { _createApp } from "./internal/createApp.impl"
 import { type AppBuilder } from "./appBuilder"
-import { type AppSdk } from "./appSdk"
+import { type DataIslandApp } from "./dataIslandApp"
 
 export * from "./events"
 export * from "./disposable"
 export * from "./credentials"
-export * from "./appSdk"
+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"
+export * from "./storages/chats/answer"
 
-const _appsNotReady = new Map<string, Promise<AppSdk>>()
-const _appsReady = new Map<string, AppSdk>()
+export {
+  OrganizationId, Organizations, OrganizationsEvent
+} from "./storages/organizations/organizations"
+export {
+  WorkspaceId, Workspaces, WorkspacesEvent
+} from "./storages/workspaces/workspaces"
+export { FileId, File, FileStatus } from "./storages/files/file"
+export { UploadFile, Files, FilesEvent } from "./storages/files/files"
+export { Group, GroupEvent, GroupId } from "./storages/groups/group"
+export { AnswerId, Answer, StepId, AnswerEvent } from "./storages/chats/answer"
+
+// 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.
@@ -26,7 +58,10 @@ export const DEFAULT_NAME = "[DEFAULT]"
  */
 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())
 }
 
@@ -37,19 +72,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)
@@ -67,7 +102,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

@@ -7,8 +7,12 @@ 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 {
+  DefaultCredential,
+  type CredentialBase,
+  AnonymousCredential
+} from "../credentials"
+import { DataIslandApp } from "../dataIslandApp"
 import { RpcService } from "../services/rpcService"
 import { CommandService } from "../services/commandService"
 import {
@@ -17,11 +21,17 @@ import {
 } from "../commands/startCommandHandler"
 import { UserProfileService } from "../services/userProfileService"
 import { OrganizationService } from "../services/organizationService"
-import { Organizations } from "../storages/organizations"
-import { UserProfile } from "../storages/userProfile"
+import { Organizations } from "../storages/organizations/organizations"
+import { UserProfile } from "../storages/user/userProfile"
 import { isUnitTest, UnitTest } from "../unitTest"
+import {
+  DeleteUserFullCommand,
+  DeleteUserFullCommandHandler
+} from "../commands/deleteUserFullCommandHandler"
+import { CookieService } from "../services/cookieService"
+import { AnonymousService } from "../services/anonymousService"
 
-export class AppImplementation extends AppSdk {
+export class DataIslandAppImpl extends DataIslandApp {
   readonly name: string
   private _host: string = DEFAULT_HOST
   private _automaticDataCollectionEnabled: boolean = true
@@ -34,7 +44,7 @@ export class AppImplementation extends AppSdk {
     this.name = name
     this._registry = new Registry()
     this._disposable = new DisposableContainer()
-    this._context = new Context(this._registry, this._disposable.lifetime, name)
+    this._context = new Context(this._registry, this._disposable.lifetime, this)
 
     this._registry.map(Context).asValue(this._context)
   }
@@ -83,8 +93,14 @@ export class AppImplementation extends AppSdk {
     builder.registerCommand(StartCommand, (context: Context) => {
       return new StartCommandHandler(context)
     })
+    builder.registerCommand(DeleteUserFullCommand, (context: Context) => {
+      return new DeleteUserFullCommandHandler(context)
+    })
 
     // register services
+    builder.registerService(CookieService, (context: ServiceContext) => {
+      return new CookieService(context)
+    })
     builder.registerService(CredentialService, (context: ServiceContext) => {
       return new CredentialService(context)
     })
@@ -103,12 +119,8 @@ export class AppImplementation extends AppSdk {
     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)
+    builder.registerService(AnonymousService, (context: ServiceContext) => {
+      return new AnonymousService(context)
     })
 
     // call customer setup
@@ -146,15 +158,15 @@ export class AppImplementation extends AppSdk {
       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
@@ -167,13 +179,31 @@ 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
     await Promise.all(waitList)
     //-------------------------------------------------------------------------
 
+    // set credential
+    this.credential = builder.credential
+
+    // Check anonymous authorization
+    if (!isUnitTest(UnitTest.DO_NOT_START) && builder.credential instanceof DefaultCredential) {
+      const anonymous = this.resolve(AnonymousService)!
+      const {
+        token,
+        isValid
+      } = await anonymous.getToken()
+
+      if (isValid) {
+        this.credential = new AnonymousCredential(token)
+      }
+    }
+
     // start app, execute start command
     if (!isUnitTest(UnitTest.DO_NOT_START)) {
       await this.context.execute(new StartCommand())
@@ -181,7 +211,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/createApp.impl.ts

@@ -1,12 +1,12 @@
-import { AppImplementation } from "./app.impl"
+import { DataIslandAppImpl } from "./app.impl"
 import { type AppBuilder } from "../appBuilder"
-import { AppSdk } from "../appSdk"
+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/middleware.ts

@@ -1,3 +1,5 @@
+import { Request, Response } from "./utils/request"
+
 /**
  * DataIsland App request middleware.
  */

package/src/services/anonymousService.ts

@@ -0,0 +1,43 @@
+import { Service } from "./service"
+import { CookieService } from "./cookieService"
+import { createFingerprint } from "../utils/browserUtils"
+import { RpcService } from "./rpcService"
+import { ResponseUtils } from "./responseUtils"
+
+export class AnonymousService extends Service {
+
+  async getToken(): Promise<{ token: string, isValid: boolean }> {
+    const cookie = this.resolve(CookieService)!
+    let token = cookie.anonymousToken
+    if (token === undefined || token === null || token.length === 0) {
+      const fingerprint = createFingerprint()
+      const response = await this.context
+        .resolve(RpcService)
+        ?.requestBuilder("api/v1/Users/anonymous")
+        .sendPutJson({
+          info: {
+            fingerprint: JSON.stringify({
+              userAgent: fingerprint.get("userAgent"),
+              language: fingerprint.get("language"),
+              hardwareConcurrency: fingerprint.get("hardware_concurrency"),
+              cookieEnabled: fingerprint.get("cookie_enabled"),
+              pixelRatio: fingerprint.get("pixel_ratio")
+            })
+          }
+        })
+
+      if (ResponseUtils.isFail(response)) {
+        await ResponseUtils.throwError("Failed to create anonymous token", response)
+      }
+
+      token = (await response!.json() as { token: string }).token
+
+      cookie.anonymousToken = token!
+    }
+
+    return {
+      token: token!,
+      isValid: token !== undefined && token !== null && token.length > 0
+    }
+  }
+}

package/src/services/commandService.ts

@@ -3,7 +3,8 @@ import { Context } from "../context"
 import { Constructor } from "../internal/registry"
 
 export abstract class CommandHandler<T> {
-  constructor(protected readonly context: Context) {}
+  constructor(protected readonly context: Context) {
+  }
 
   resolve<T>(type: Constructor<T>): T | undefined {
     return this.context.resolve<T>(type)
@@ -12,7 +13,8 @@ export abstract class CommandHandler<T> {
   abstract execute(message: T): Promise<void>
 }
 
-export abstract class Command {}
+export abstract class Command {
+}
 
 export class CommandService extends Service {
   private readonly _registry: Map<

package/src/services/cookieService.ts

@@ -0,0 +1,16 @@
+import { Service } from "./service"
+import { getCookie, setCookie } from "../utils/browserUtils"
+
+export class CookieService extends Service {
+  get anonymousToken(): string | undefined {
+    return getCookie("anonymous-token")
+  }
+
+  get anonymousTokenIsValid(): boolean {
+    return this.anonymousToken !== undefined && this.anonymousToken !== null && this.anonymousToken.length > 0
+  }
+
+  set anonymousToken(value: string | undefined) {
+    setCookie("anonymous-token", value)
+  }
+}

package/src/services/httpMethod.ts

@@ -0,0 +1 @@
+export type HttpMethod = "POST" | "GET" | "PUT" | "DELETE" | "PATCH"

package/src/services/middlewareService.ts

@@ -1,9 +1,10 @@
 import { Service } from "./service"
 import { type Middleware } from "../middleware"
 import { type Disposable } from "../disposable"
+import { Request, Response } from "../utils/request"
 
 export class MiddlewareService extends Service {
-  _middlewares: Middleware[] = []
+  private _middlewares: Middleware[] = []
 
   public useMiddleware(middleware: Middleware): Disposable {
     this._middlewares.push(middleware)

package/src/services/organizationService.ts

@@ -1,7 +1,7 @@
 import { Service } from "./service"
-import { Organizations } from "../storages/organizations"
+import { Organizations } from "../storages/organizations/organizations"
 import { OrganizationDto, UserSettings } from "../dto/userInfoResponse"
-import { OrganizationsImpl } from "../storages/organizations.impl"
+import { OrganizationsImpl } from "../storages/organizations/organizations.impl"
 
 export class OrganizationService extends Service {
   private _impl?: OrganizationsImpl

package/src/services/requestBuilder.ts

@@ -1,17 +1,19 @@
+// import { Request, Response, Headers, FormData } from "../utils/request"
+
 export class RequestBuilder {
-  private readonly _headers: Headers
+  private readonly _headers: Record<string, string>
   private readonly _searchParams: URLSearchParams
 
   constructor(
     private readonly _url: URL,
     private readonly _request: (req: Request) => Promise<Response>
   ) {
-    this._headers = new Headers()
+    this._headers = {}
     this._searchParams = new URLSearchParams()
   }
 
   public header(name: string, value: string): RequestBuilder {
-    this._headers.set(name, value)
+    this._headers[name] = value
     return this
   }
 
@@ -23,11 +25,11 @@ export class RequestBuilder {
     }
     if (headers instanceof Headers) {
       headers.forEach((value, name) => {
-        this._headers.set(name, value)
+        this._headers[name] = value
       })
     } else {
       Object.entries(headers).forEach(([name, value]) => {
-        this._headers.set(name, value)
+        this._headers[name] = value
       })
     }
     return this
@@ -48,18 +50,42 @@ export class RequestBuilder {
     return this
   }
 
-  public async sendPost(body?: BodyInit | null | object): Promise<Response> {
+  public async sendPostFormData(body: FormData): Promise<Response> {
+    const url = this._url
+
+    // set search params
+    url.search = this._searchParams.toString()
+
+    // create request
+    const req = new Request(url, {
+      method: "POST",
+      headers: this._headers,
+      body: body
+    })
+
+    // discard content type
+    const reqAny = req as any
+    reqAny.discardContentType = true
+
+    return await this._request(
+      req
+    )
+  }
+
+  public async sendPostJson(body: object | null | undefined): Promise<Response> {
     const url = this._url
     url.search = this._searchParams.toString()
+    let json: string | undefined = undefined
     if (body !== undefined && body !== null && typeof body === "object") {
-      body = JSON.stringify(body)
+      json = JSON.stringify(body)
     }
+    const request = new Request(url, {
+      method: "POST",
+      headers: this._headers,
+      body: json
+    })
     return await this._request(
-      new Request(url, {
-        method: "POST",
-        headers: this._headers,
-        body
-      })
+      request
     )
   }
 
@@ -85,17 +111,18 @@ export class RequestBuilder {
     )
   }
 
-  public async sendPut(body?: BodyInit | null | object): Promise<Response> {
+  public async sendPutJson(body: object | null | undefined): Promise<Response> {
     const url = this._url
     url.search = this._searchParams.toString()
+    let json: string | undefined = undefined
     if (body !== undefined && body !== null && typeof body === "object") {
-      body = JSON.stringify(body)
+      json = JSON.stringify(body)
     }
     return await this._request(
       new Request(url, {
         method: "PUT",
         headers: this._headers,
-        body
+        body: json
       })
     )
   }

package/src/services/responseUtils.ts

@@ -1,3 +1,5 @@
+import { Response } from "../utils/request"
+
 export class ResponseUtils {
   public static isOk(response?: Response | null): boolean {
     return response !== undefined && response !== null && response.ok