@neuralinnovations/dataisland-sdk 0.0.1-dev8 → 0.0.1-dev81

package/src/dto/userInfoResponse.ts

@@ -1,4 +1,8 @@
 import { WorkspaceDto } from "./workspacesResponse"
+import { UserId } from "../storages/user/userProfile"
+import { OrganizationId } from "../storages/organizations/organizations"
+import { StatisticsData } from "./statisticsResponse"
+import { LimitActionType, SegmentData } from "./limitsResponse"
 
 export interface UserInfoResponse {
   adminInOrganization: string[]
@@ -7,8 +11,9 @@ export interface UserInfoResponse {
 }
 
 export interface UserDto {
-  id: string
+  id: UserId
   isDeleted: boolean
+  isAnonymousMode: boolean
   created_at: number
   modified_at: number
   profile: ProfileDto
@@ -18,20 +23,25 @@ export interface UserDto {
 export interface ProfileDto {
   name: string
   email: string
+  binanceId: string
+  educationalInstitution: string
 }
 
 export interface UserSettings {
   activeOrganizationId: string
   activeWorkspaceId: string
+  limitSegmentKey: string
 }
 
 export interface OrganizationProfileDto {
   name: string
   description: string
+  iconId: string
+  isAllowedInLibraries: boolean
 }
 
 export interface OrganizationDto {
-  id: string
+  id: OrganizationId
   createdAt: number
   modifiedAt: number
   membersCount: number
@@ -45,3 +55,56 @@ export interface OrganizationWorkspaces extends OrganizationDto {
 export interface MembersResponse {
   members: UserDto
 }
+
+export interface ApplyInviteCodeResponse {
+  organizationId: string
+}
+
+export interface UsersStatisticsResponse {
+  dateFrom: number
+  dateTo: number
+  membersData: UserStatisticsData[]
+}
+
+export interface UserStatisticsData {
+  userId: UserId
+  data: StatisticsData[]
+}
+
+export interface OrganizationSegmentData {
+  segment: SegmentData
+}
+
+export interface UserLimitsData {
+  userSegment: SegmentData
+  userLimits: UserLimitData[]
+}
+
+export interface UserLimitData {
+  action: LimitActionType
+  records: UserLimitRecordData[]
+}
+
+export interface UserLimitRecordData {
+  daysCount: number
+  countLimit: number
+  tokenLimit?: number
+  activeTill: number
+}
+
+export interface CurrentLimitsData {
+  segment: string
+  limits: CurrentLimitItem[]
+}
+
+export interface CurrentLimitItem {
+  action: LimitActionType
+  records: CurrentLimitRecordData[]
+}
+
+export interface CurrentLimitRecordData  {
+  daysCount: number
+  used: number
+  all: number
+  activeTill: number
+}

package/src/dto/workspacesResponse.ts

@@ -1,9 +1,10 @@
-import { WorkspaceId } from "../storages/workspaces"
-import { FileId } from "../storages/file"
+import { WorkspaceId } from "../storages/workspaces/workspaces"
+import { FileId } from "../storages/files/file"
 
 export interface WorkspaceProfileDto {
   name: string
   description: string
+  isShared: boolean
 }
 
 export interface WorkspaceDto {
@@ -18,14 +19,23 @@ export interface WorkspacesResponse {
 }
 
 export interface FileUrlDto {
-  url: string
+  url: string,
+  previewUrl: string
+}
+
+export enum FileProcessingStage {
+  None = 0,
+  WAITING_CONVERTING = 10,
+  CONVERTING = 11,
+  WAITING_PROCESSING = 20,
+  PROCESSING = 21,
+  ERROR = 99,
+  DONE = 100
 }
 
 export interface FileProgressDto {
   file_id: FileId
-  file_parts_count: number
-  completed_parts_count: number
-  success: boolean
+  stage: FileProcessingStage
   error?: string
 }
 
@@ -35,15 +45,53 @@ export interface FileDto {
   modifiedAt: number
   name: string
   description: string
+  fileMetadata: string
   url: string
+  previewUrl: string
   hash: string
   organizationId: string
   workspaceId: string
-  isProcessedSuccessfully: boolean
+  stage: FileProcessingStage
+}
+
+export interface FilesBatchFetchResponse {
+  progress: FileProgressDto[]
+}
+
+export class MetadataDto {
+  public key: string
+  public value: string
+
+  constructor(key: string, value: string){
+    this.key = key
+    this.value = value
+  }
 }
 
+
 export interface FileListResponse {
   files: FileDto[]
   totalFilesCount: number
   filesPerPage: number
 }
+
+export interface IconResponse {
+  iconId: string
+}
+
+export interface IconDto {
+  iconId: string,
+  iconUrl: string,
+  iconName: string
+}
+
+export enum ResourceType {
+  None = 0,
+  Organization = 1,
+  Workspace = 2,
+  Chat = 3,
+  Group = 4,
+  User = 5,
+  File = 6
+}
+

package/src/index.ts

@@ -3,23 +3,83 @@ import { _createApp } from "./internal/createApp.impl"
 import { type AppBuilder } from "./appBuilder"
 import { type DataIslandApp } from "./dataIslandApp"
 
-export * from "./events"
-export * from "./disposable"
+export * from "./appBuilder"
+export * from "./context"
 export * from "./credentials"
 export * from "./dataIslandApp"
-export * from "./storages/organizations"
-export * from "./storages/organization"
-export * from "./storages/workspaces"
-export * from "./storages/workspace"
-export * from "./storages/groups"
-export * from "./storages/userProfile"
-export * from "./storages/files"
-export * from "./storages/file"
-export * from "./storages/filesPage"
-export * from "./storages/chats"
-export * from "./storages/chat"
+export * from "./disposable"
+export * from "./dto/accessGroupResponse"
+export * from "./dto/quizResponse"
+export * from "./dto/acquiringResponse"
+export * from "./dto/badRequestResponse"
+export * from "./dto/chatResponse"
+export * from "./dto/limitsResponse"
+export * from "./dto/statisticsResponse"
+export * from "./dto/userInfoResponse"
+export * from "./dto/workspacesResponse"
+export * from "./dto/invitesResponse"
+export * from "./dto/apiKeyResponse"
+export * from "./dto/libraryResponse"
+export * from "./dto/queryFlowResponse"
+export * from "./events"
+export * from "./middleware"
+export * from "./storages/chats/answer"
+export * from "./storages/chats/chat"
+export * from "./storages/chats/chats"
+export * from "./storages/files/file"
+export * from "./storages/files/files"
+export * from "./storages/files/filesPage"
+export * from "./storages/groups/groups"
+export * from "./storages/organizations/organization"
+export * from "./storages/organizations/organizations"
+export * from "./storages/user/userProfile"
+export * from "./storages/workspaces/workspace"
+export * from "./storages/workspaces/workspaces"
+export * from "./storages/library/library"
+export * from "./storages/library/libraryPage"
+export * from "./storages/library/libraryFolder"
+export * from "./storages/queryFlows/queryFlow"
+export * from "./storages/queryFlows/queryFlows"
 
+export {
+  OrganizationId, Organizations, OrganizationsEvent
+} from "./storages/organizations/organizations"
+export {
+  WorkspaceId, Workspaces, WorkspacesEvent
+} from "./storages/workspaces/workspaces"
+export { FileId, File } 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"
+export { isNullOrUndefined, isEmptyNullOrUndefined } from "./utils/utils"
+export {
+  AcquiringPlan,
+  AcquiringSegmentData,
+  OrderData,
+  OrderResponse,
+  GetOrderStateResponse,
+  OrderState,
+  UserAcquiringPlan,
+  UnsubscribeResponse
+} from "./dto/acquiringResponse"
+export {
+  LimitActionType,
+  SegmentActionData,
+  SegmentData,
+  SegmentItemData,
+  SegmentsData
+} from "./dto/limitsResponse"
+
+export { FolderId } from "./storages/library/folderId"
+export { LibraryId } from "./storages/library/libraryId"
+export { Library } from "./storages/library/library"
+export { Libraries, LibraryManagement } from "./storages/library/libraries"
+export { LibraryPage, LibraryParent } from "./storages/library/libraryPage"
+export { LibraryFolder } from "./storages/library/libraryFolder"
+
+// 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>()
 
 /**
@@ -87,6 +147,3 @@ export async function dataIslandApp(
   }
   return await appPromise
 }
-
-export { File } from "./storages/file"
-export { FilesPage } from "./storages/filesPage"

package/src/internal/app.impl.ts

@@ -7,7 +7,11 @@ 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 {
+  DefaultCredential,
+  type CredentialBase,
+  AnonymousCredential
+} from "../credentials"
 import { DataIslandApp } from "../dataIslandApp"
 import { RpcService } from "../services/rpcService"
 import { CommandService } from "../services/commandService"
@@ -17,9 +21,19 @@ 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"
+import { Acquiring } from "../storages/acquirings/acquiring"
+import { AcquiringService } from "../services/acquiringService"
+import {Libraries} from "../storages/library/libraries"
+import {LibrariesService} from "../services/librariesService"
 
 export class DataIslandAppImpl extends DataIslandApp {
   readonly name: string
@@ -34,7 +48,7 @@ export class DataIslandAppImpl extends DataIslandApp {
     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)
   }
@@ -73,6 +87,14 @@ export class DataIslandAppImpl extends DataIslandApp {
     return this.resolve(UserProfileService)?.userProfile as UserProfile
   }
 
+  get acquiring(): Acquiring {
+    return (this.resolve(AcquiringService) as AcquiringService).acquiring
+  }
+
+  get libraries(): Libraries {
+    return (this.resolve(LibrariesService) as LibrariesService).libraries
+  }
+
   async initialize(
     setup: ((builder: AppBuilder) => Promise<void>) | undefined
   ): Promise<void> {
@@ -83,8 +105,14 @@ export class DataIslandAppImpl extends DataIslandApp {
     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,6 +131,15 @@ export class DataIslandAppImpl extends DataIslandApp {
     builder.registerService(OrganizationService, (context: ServiceContext) => {
       return new OrganizationService(context)
     })
+    builder.registerService(AnonymousService, (context: ServiceContext) => {
+      return new AnonymousService(context)
+    })
+    builder.registerService(AcquiringService, (context: ServiceContext) => {
+      return new AcquiringService(context)
+    })
+    builder.registerService(LibrariesService, (context: ServiceContext) => {
+      return new LibrariesService(context)
+    })
 
     // call customer setup
     if (setup !== undefined) {
@@ -123,10 +160,10 @@ export class DataIslandAppImpl extends DataIslandApp {
         this._context,
         this._disposable.defineNested()
       )
+      const serviceInstance = serviceFactory[1](serviceContext)
       serviceContext.lifetime.addCallback(() => {
-        serviceContext.onUnregister()
+        serviceContext.onUnregister.call(serviceInstance)
       }, serviceContext)
-      const serviceInstance = serviceFactory[1](serviceContext)
       services.push([serviceContext, serviceInstance])
       this._registry.map(serviceFactory[0]).asValue(serviceInstance)
     })
@@ -139,16 +176,14 @@ export class DataIslandAppImpl extends DataIslandApp {
       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]) => {
+    services.forEach(([serviceContext, service]) => {
       if (typeof serviceContext.onRegister === "function") {
-        waitList.push(serviceContext.onRegister())
+        waitList.push(serviceContext.onRegister.call(service))
       }
     })
 
@@ -161,9 +196,9 @@ export class DataIslandAppImpl extends DataIslandApp {
     //-------------------------------------------------------------------------
     waitList.length = 0
     // call onStart service's callback
-    services.forEach(([serviceContext]) => {
+    services.forEach(([serviceContext, service]) => {
       if (typeof serviceContext.onStart === "function") {
-        waitList.push(serviceContext.onStart())
+        waitList.push(serviceContext.onStart.call(service))
       }
     })
 
@@ -171,6 +206,22 @@ export class DataIslandAppImpl extends DataIslandApp {
     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())

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/acquiringService.ts

@@ -0,0 +1,21 @@
+import { Service, ServiceContext } from "./service"
+import { AcquiringImpl } from "../storages/acquirings/acquiring.impl"
+import { Acquiring } from "../storages/acquirings/acquiring"
+
+export class AcquiringService extends Service {
+  private readonly _acquiring: AcquiringImpl
+
+  constructor(serviceContext: ServiceContext) {
+    super(serviceContext)
+
+    this._acquiring = new AcquiringImpl(serviceContext.context)
+  }
+
+  async initialize(): Promise<void> {
+    return await this._acquiring.initialize()
+  }
+
+  get acquiring(): Acquiring {
+    return this._acquiring
+  }
+}

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"