@neuralinnovations/dataisland-sdk 0.0.1-dev6 → 0.0.1-dev60

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,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"
+import { Acquiring } from "../storages/acquirings/acquiring"
+import { AcquiringService } from "../services/acquiringService"
 
 export class DataIslandAppImpl extends DataIslandApp {
   readonly name: string
@@ -34,7 +46,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 +85,10 @@ export class DataIslandAppImpl extends DataIslandApp {
     return this.resolve(UserProfileService)?.userProfile as UserProfile
   }
 
+  get acquiring(): Acquiring {
+    return (this.resolve(AcquiringService) as AcquiringService).acquiring
+  }
+
   async initialize(
     setup: ((builder: AppBuilder) => Promise<void>) | undefined
   ): Promise<void> {
@@ -83,8 +99,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 +125,12 @@ 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)
+    })
 
     // call customer setup
     if (setup !== undefined) {
@@ -123,10 +151,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 +167,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 +187,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 +197,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)
+  }
+
+  initialize(): Promise<void> {
+    return 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"

package/src/services/middlewareService.ts

@@ -1,6 +1,7 @@
 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 {
   private _middlewares: 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
@@ -58,7 +60,7 @@ export class RequestBuilder {
     const req = new Request(url, {
       method: "POST",
       headers: this._headers,
-      body
+      body: body
     })
 
     // discard content type
@@ -73,7 +75,7 @@ export class RequestBuilder {
   public async sendPostJson(body: object | null | undefined): Promise<Response> {
     const url = this._url
     url.search = this._searchParams.toString()
-    let json: string | null | undefined = null
+    let json: string | undefined = undefined
     if (body !== undefined && body !== null && typeof body === "object") {
       json = JSON.stringify(body)
     }
@@ -112,7 +114,7 @@ export class RequestBuilder {
   public async sendPutJson(body: object | null | undefined): Promise<Response> {
     const url = this._url
     url.search = this._searchParams.toString()
-    let json: string | null | undefined = null
+    let json: string | undefined = undefined
     if (body !== undefined && body !== null && typeof body === "object") {
       json = JSON.stringify(body)
     }

package/src/services/responseUtils.ts

@@ -1,3 +1,6 @@
+import { BadRequest } from "../dto/badRequestResponse"
+import { Response } from "../utils/request"
+
 export class ResponseUtils {
   public static isOk(response?: Response | null): boolean {
     return response !== undefined && response !== null && response.ok
@@ -7,6 +10,15 @@ export class ResponseUtils {
     return !ResponseUtils.isOk(response)
   }
 
+  public static async isLimitReached(response?: Response | null): Promise<boolean> {
+    if (response?.status == 15){
+      if (((await response?.json()) as BadRequest).code == 15){
+        return true
+      }
+    }
+    return false
+  }
+
   public static async throwError(
     message: string,
     response: Response | undefined | null

package/src/services/rpcService.ts

@@ -1,6 +1,7 @@
 import { Service, type ServiceContext } from "./service"
 import { MiddlewareService } from "./middlewareService"
 import { RequestBuilder } from "./requestBuilder"
+// import { Request, Response, Headers, fetch } from "../utils/request"
 
 /**
  * Options for the RpcService.

package/src/services/userProfileService.ts

@@ -1,21 +1,36 @@
 import { Service } from "./service"
 import { RpcService } from "./rpcService"
-import { UserProfile } from "../storages/userProfile"
+import { UserProfile } from "../storages/user/userProfile"
 import { UserInfoResponse } from "../dto/userInfoResponse"
 import { OrganizationService } from "./organizationService"
-import { UserProfileImpl } from "../storages/userProfile.impl"
+import { UserProfileImpl } from "../storages/user/userProfile.impl"
 import { ResponseUtils } from "./responseUtils"
+import { OrganizationsEvent } from "../storages/organizations/organizations"
 
 export class UserProfileService extends Service {
-  private readonly impl: UserProfileImpl = new UserProfileImpl()
+  private readonly impl: UserProfileImpl = new UserProfileImpl(this.context)
 
   get userProfile(): UserProfile {
     return this.impl
   }
 
+  async merge(anonymous_token: string) {
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Users/anonymous/merge")
+      .sendPostJson({
+        anonymousToken: anonymous_token
+      })
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to merge anonymous user", response)
+    }
+
+    await this.fetch()
+  }
+
   async fetch() {
     const rpc = this.resolve(RpcService) as RpcService
-    const response = await rpc.requestBuilder("api/v1/Users/self2").sendGet()
+    const response = await rpc.requestBuilder("api/v2/Users/self").sendGet()
     if (ResponseUtils.isFail(response)) {
       await ResponseUtils.throwError("Failed to fetch user profile", response)
     }
@@ -34,5 +49,22 @@ export class UserProfileService extends Service {
       content.organizations,
       content.user.settings
     )
+
+    organizationService.organizations.subscribe(async (event) => {
+      this.updateUserSettings(event.data.id)
+    }, OrganizationsEvent.CURRENT_CHANGED)
+  }
+
+  async updateUserSettings(activeOrgId?: string, activeWorkspaceId?: string): Promise<void>{
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Users/settings").sendPutJson({
+      settings: {
+        activeOrganizationId: activeOrgId,
+        activeWorkspaceId: activeWorkspaceId
+      }
+    })
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to update user settings", response)
+    }
   }
 }

package/src/storages/acquirings/acquiring.impl.ts

@@ -0,0 +1,132 @@
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+import {
+  AcquiringPlansResponse,
+  OrderResponse,
+  OrderData,
+  UserAcquiringPlan,
+  GetOrderStateResponse,
+  AcquiringPlan,
+  AcquiringSegmentData,
+  UnsubscribeResponse
+} from "../../dto/acquiringResponse"
+import { Acquiring } from "./acquiring"
+import { Context } from "../../context"
+
+export class AcquiringImpl implements Acquiring {
+  private _userPlan?: UserAcquiringPlan
+  private _plans?: AcquiringPlan[]
+  private _limitSegments?: AcquiringSegmentData[]
+
+  constructor(
+    private readonly context: Context) {
+  }
+
+  get userPlan(): UserAcquiringPlan {
+    return this._userPlan!
+  }
+
+  get plans(): AcquiringPlan[] {
+    return this._plans!
+  }
+
+  get limitSegments(): AcquiringSegmentData[] {
+    return this._limitSegments!
+  }
+
+  async initialize() {
+    const userPlanPromise = this.getUserPlan()
+    const plansPromise = this.getPlans()
+    const promises = [
+      userPlanPromise,
+      plansPromise
+    ]
+    await Promise.all(promises)
+
+    this._userPlan = await userPlanPromise
+    const {
+      plans,
+      limitSegments
+    } = await plansPromise
+    this._plans = plans
+    this._limitSegments = limitSegments
+  }
+
+  async createOrder(key: string): Promise<OrderData> {
+    const rpc = this.context.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Acquiring/order")
+      .sendPostJson({
+        key: key
+      })
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to create order", response)
+    }
+
+    const order = (await response.json()) as OrderResponse
+
+    return order.data
+  }
+
+  async unsubscribe(): Promise<UnsubscribeResponse> {
+    const rpc = this.context.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder("api/v1/Acquiring/unsubscribe").sendDelete()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to unsubscribe", response)
+    }
+
+    const order = (await response.json()) as UnsubscribeResponse
+
+    return order
+  }
+
+  async getPlans(): Promise<AcquiringPlansResponse> {
+    const rpc = this.context.resolve(RpcService) as RpcService
+    const response = await rpc
+      .requestBuilder("api/v1/Acquiring/plans")
+      .sendGet()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to get acquiring plans", response)
+    }
+
+    const content = (await response.json()) as AcquiringPlansResponse
+    this._plans = content.plans
+    this._limitSegments = content.limitSegments
+
+    return content
+  }
+
+  async getUserPlan(): Promise<UserAcquiringPlan> {
+    const rpc = this.context.resolve(RpcService) as RpcService
+    const response = await rpc
+      .requestBuilder("api/v1/Acquiring/user/subscription")
+      .sendGet()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to get user subscription", response)
+    }
+
+    const content = (await response.json()) as UserAcquiringPlan
+    this._userPlan = content
+
+    return content
+  }
+
+  async getOrder(orderId: string): Promise<GetOrderStateResponse> {
+    const rpc = this.context.resolve(RpcService) as RpcService
+    const response = await rpc
+      .requestBuilder("api/v1/Acquiring/order/state")
+      .searchParam("orderId", orderId)
+      .sendGet()
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to get order", response)
+    }
+
+    const content = (await response.json()) as GetOrderStateResponse
+
+    return content
+  }
+}