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

package/src/services/organizationService.ts

@@ -0,0 +1,126 @@
+import { Service } from './service'
+import {
+  OrganizationEvent,
+  OrganizationId,
+  Organizations
+} from '../storages/organizations'
+import { OrganizationDto, UserSettings } from '../dto/userInfoResponse'
+import { RpcService } from './rpcService'
+import { OrganizationImpl } from './organizationImpl'
+import { OrganizationsImpl } from './organizationsImpl'
+
+export class OrganizationService extends Service {
+  private impl: OrganizationsImpl = new OrganizationsImpl(this)
+
+  get organizations(): Organizations {
+    return this.impl
+  }
+
+  initFrom(
+    settings: UserSettings,
+    adminInOrganization: string[],
+    organizations: OrganizationDto[]
+  ) {
+    this.impl.currentOrganizationId = settings.activeOrganizationId
+    for (const organization of organizations) {
+      const org = new OrganizationImpl(this, this.impl).initFrom(
+        organization,
+        adminInOrganization.includes(organization.id)
+      )
+      // add organization to collection
+      this.impl.organizations.push(org)
+
+      // dispatch event, organization added
+      this.impl.dispatch({
+        type: OrganizationEvent.ADDED,
+        data: org
+      })
+    }
+  }
+
+  async deleteOrganization(id: OrganizationId): Promise<void> {
+    if (id === undefined || id === null) {
+      throw new Error('Organization delete, id is undefined or null')
+    }
+    if (id.length === 0 || id.trim().length === 0) {
+      throw new Error('Organization delete, id is empty')
+    }
+    if (!this.impl.contains(id)) {
+      throw new Error(`Organization delete, id: ${id} is not found`)
+    }
+    const response = await this.resolve(RpcService)
+      ?.requestBuilder('/api/v1/Organizations')
+      .searchParam('id', id)
+      .sendDelete()
+    if (!response?.ok) {
+      let text: string = ''
+      try {
+        text = (await response?.text()) ?? ''
+      } catch (e) {
+        console.error(e)
+      }
+
+      throw new Error(
+        `Organization delete, response is not ok, status: ${response?.status},${response?.statusText} ${text}`
+      )
+    }
+    const org = <OrganizationImpl>this.impl.get(id)
+    const index = this.impl.organizations.indexOf(org)
+    if (index < 0) {
+      throw new Error('Organization delete, index is not found')
+    }
+
+    // remove organization from collection
+    this.impl.organizations.splice(index, 1)
+
+    // dispatch event, organization removed
+    this.impl.dispatch({
+      type: OrganizationEvent.REMOVED,
+      data: org
+    })
+
+    // dispose organization
+    org.dispose()
+  }
+
+  async createOrganization(
+    name: string,
+    description: string
+  ): Promise<OrganizationImpl> {
+    if (name === undefined || name === null) {
+      throw new Error('Organization create, name is undefined or null')
+    }
+    if (description === undefined || description === null) {
+      throw new Error('Organization create, description is undefined or null')
+    }
+    if (name.length === 0 || name.trim().length === 0) {
+      throw new Error('Organization create, name is empty')
+    }
+    const response = await this.resolve(RpcService)
+      ?.requestBuilder('api/v1/Organizations')
+      .sendPost({
+        profile: {
+          name: name,
+          description: description
+        }
+      })
+    if (!response?.ok) {
+      throw new Error('Organization create, response is not ok')
+    }
+    const content = (await response.json())['organization'] as OrganizationDto
+
+    // create organization and init from content
+    const org = new OrganizationImpl(this, this.impl).initFrom(content, true)
+
+    // add organization to collection
+    this.impl.organizations.push(org)
+
+    // dispatch event, organization added
+    this.impl.dispatch({
+      type: OrganizationEvent.ADDED,
+      data: org
+    })
+
+    return org
+  }
+}

package/src/services/organizationsImpl.ts

@@ -0,0 +1,55 @@
+import {
+  Organization,
+  OrganizationEvent,
+  OrganizationId,
+  Organizations
+} from '../storages/organizations'
+import { OrganizationImpl } from './organizationImpl'
+import { OrganizationService } from './organizationService'
+
+export class OrganizationsImpl extends Organizations {
+  constructor(public readonly service: OrganizationService) {
+    super()
+  }
+
+  public organizations: OrganizationImpl[] = []
+  public currentOrganizationId?: OrganizationId
+
+  get collection(): readonly Organization[] {
+    return this.organizations
+  }
+
+  get current(): OrganizationId {
+    return <OrganizationId>this.currentOrganizationId
+  }
+
+  set current(value: OrganizationId) {
+    if (this.currentOrganizationId !== value) {
+      this.currentOrganizationId = value
+      this.dispatch({
+        type: OrganizationEvent.CURRENT_CHANGED,
+        data: this
+      })
+    }
+  }
+
+  get(id: OrganizationId): Organization {
+    return <Organization>this.tryGet(id)
+  }
+
+  tryGet(id: OrganizationId): Organization | undefined {
+    return this.organizations.find(organization => organization.id === id)
+  }
+
+  contains(id: OrganizationId): boolean {
+    return this.organizations.some(organization => organization.id === id)
+  }
+
+  async create(name: string, description: string): Promise<Organization> {
+    return this.service.createOrganization(name, description)
+  }
+
+  delete(id: string): Promise<void> {
+    return this.service.deleteOrganization(id)
+  }
+}

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

@@ -1,72 +1,132 @@
 import { Service, type ServiceContext } from './service'
 import { MiddlewareService } from './middlewareService'
+import { RequestBuilder } from './requestBuilder'
 
-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')
-  }
+/**
+ * Options for the RpcService.
+ */
+export interface RequestOptions {
+  searchParams?: Map<string, string>
+  headers?: [string, string][] | Record<string, string> | Headers
+}
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  buildUrl(path: string): string {
-    throw new Error('Not implemented')
+/**
+ * RPC service.
+ */
+export class RpcService extends Service {
+  constructor(
+    serviceContext: ServiceContext,
+    /**
+     * Host of the RPC service.
+     * It is not used if you use the `urlBuilder` option.
+     */
+    public readonly host: string,
+    /**
+     * Options for the RpcService.
+     */
+    private readonly options?: {
+      // make it possible to override the url builder
+      urlBuilder?: (path: string) => URL
+      // make it possible to override the fetch method
+      fetchMethod?: (uri: Request) => Promise<Response>
+    }
+  ) {
+    super(serviceContext)
   }
 
-  async get(path: string): Promise<Response> {
-    return await this.request(
-      new Request(this.buildUrl(path), {
-        method: 'GET'
+  /**
+   * Request method.
+   */
+  async request(req: Request): Promise<Response> {
+    const middlewareService = this.resolve(MiddlewareService)
+    if (middlewareService !== undefined) {
+      return await middlewareService.process(req, async req => {
+        return (await this.options?.fetchMethod?.(req)) ?? (await fetch(req))
       })
-    )
+    }
+    return (await this.options?.fetchMethod?.(req)) ?? (await fetch(req))
   }
 
-  async post(path: string, body?: BodyInit | null): Promise<Response> {
-    return await this.request(
-      new Request(this.buildUrl(path), {
-        method: 'POST',
-        body
-      })
-    )
+  /**
+   * Build URL.
+   * @param path
+   */
+  buildUrl(path: string): URL {
+    if (this.options !== undefined && this.options.urlBuilder !== undefined) {
+      return this.options.urlBuilder(path)
+    }
+    if (this.host.endsWith('/') && path.startsWith('/')) {
+      return new URL(`${this.host}${path.slice(1)}`)
+    }
+    if (!this.host.endsWith('/') && !path.startsWith('/')) {
+      return new URL(`${this.host}/${path}`)
+    }
+    return new URL(`${this.host}${path}`)
   }
 
-  async put(path: string, body?: BodyInit | null): Promise<Response> {
-    return await this.request(
-      new Request(this.buildUrl(path), {
-        method: 'PUT',
-        body
-      })
-    )
+  /**
+   * Create a request builder.
+   * @param path
+   */
+  requestBuilder(path: string): RequestBuilder {
+    return new RequestBuilder(this.buildUrl(path), this.request.bind(this))
   }
 
-  async delete(path: string): Promise<Response> {
-    return await this.request(
-      new Request(this.buildUrl(path), {
-        method: 'DELETE'
-      })
-    )
+  /**
+   * Send a GET request.
+   * @param path
+   * @param options
+   */
+  async get(path: string, options?: RequestOptions): Promise<Response> {
+    return this.requestBuilder(path)
+      .searchParams(options?.searchParams)
+      .headers(options?.headers)
+      .sendGet()
   }
-}
 
-export class RpcServiceImpl extends RpcService {
-  constructor(serviceContext: ServiceContext, public readonly host: string) {
-    super(serviceContext)
+  /**
+   * Send a POST request.
+   * @param path
+   * @param body
+   * @param options
+   */
+  async post(
+    path: string,
+    body?: BodyInit | null,
+    options?: RequestOptions
+  ): Promise<Response> {
+    return this.requestBuilder(path)
+      .searchParams(options?.searchParams)
+      .headers(options?.headers)
+      .sendPost(body)
   }
 
-  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)
-    }
+  /**
+   * Send a PUT request.
+   * @param path
+   * @param body
+   * @param options
+   */
+  async put(
+    path: string,
+    body?: BodyInit | null,
+    options?: RequestOptions
+  ): Promise<Response> {
+    return this.requestBuilder(path)
+      .searchParams(options?.searchParams)
+      .headers(options?.headers)
+      .sendPut(body)
   }
 
-  override buildUrl(path: string): string {
-    if (this.host.endsWith('/') && path.startsWith('/')) {
-      return `${this.host}${path.slice(1)}`
-    }
-    return `${this.host}${path}`
+  /**
+   * Send a DELETE request.
+   * @param path
+   * @param options
+   */
+  async delete(path: string, options?: RequestOptions): Promise<Response> {
+    return this.requestBuilder(path)
+      .searchParams(options?.searchParams)
+      .headers(options?.headers)
+      .sendDelete()
   }
 }

package/src/services/service.ts

@@ -1,4 +1,4 @@
-import { type Context } from '../internal/context'
+import { type Context } from '../context'
 import { type Constructor } from '../internal/registry'
 import { type DisposableContainer, type Lifetime } from '../disposable'
 

package/src/services/userProfileService.ts

@@ -0,0 +1,86 @@
+import { Service } from './service'
+import { RpcService } from './rpcService'
+import { UserEvent, UserProfile } from '../storages/userProfile'
+import { UserInfoResponse } from '../dto/userInfoResponse'
+import { OrganizationService } from './organizationService'
+
+class UserProfileImpl extends UserProfile {
+  private content?: UserInfoResponse
+
+  get id(): string {
+    if (this.content) {
+      return this.content.user.id
+    }
+    throw new Error('The profile is not loaded.')
+  }
+
+  get name(): string {
+    if (this.content) {
+      return this.content.user.profile.name
+    }
+    throw new Error('The profile is not loaded.')
+  }
+
+  get email(): string {
+    if (this.content) {
+      return this.content.user.profile.email
+    }
+    throw new Error('The profile is not loaded.')
+  }
+
+  get isDeleted(): boolean {
+    if (this.content) {
+      return this.content.user.isDeleted
+    }
+    throw new Error('The profile is not loaded.')
+  }
+
+  get createdAt(): Date {
+    if (this.content) {
+      return new Date(this.content.user.created_at)
+    }
+    throw new Error('The profile is not loaded.')
+  }
+
+  get modifiedAt(): Date {
+    if (this.content) {
+      return new Date(this.content.user.modified_at)
+    }
+    throw new Error('The profile is not loaded.')
+  }
+
+  initFrom(content: UserInfoResponse) {
+    this.content = content
+    this.dispatch({
+      type: UserEvent.CHANGED,
+      data: this
+    })
+  }
+}
+
+export class UserProfileService extends Service {
+  private readonly impl: UserProfileImpl = new UserProfileImpl()
+
+  get userProfile(): UserProfile {
+    return this.impl
+  }
+
+  async fetch(fireError: boolean = true) {
+    const rpc = this.resolve(RpcService) as RpcService
+    const response = await rpc.requestBuilder('api/v1/Users/self2').sendGet()
+    if (fireError && !response.ok) {
+      throw new Error('Failed to fetch user profile.')
+    }
+    const content = (await response.json()) as UserInfoResponse
+    this.impl.initFrom(content)
+
+    const organizationService = this.resolve(
+      OrganizationService
+    ) as OrganizationService
+    organizationService.initFrom(
+      content.user.settings,
+      content.adminInOrganization,
+      content.organizations
+    )
+  }
+}

package/src/storages/organizations.ts

@@ -0,0 +1,76 @@
+import { EventDispatcher } from '../events'
+
+/**
+ * Organization id.
+ */
+export type OrganizationId = string
+
+/**
+ * Organization.
+ */
+export abstract class Organization {
+  /**
+   * Organization id.
+   */
+  abstract get id(): OrganizationId
+
+  /**
+   * Organization name.
+   */
+  abstract get name(): string
+
+  /**
+   * Organization description.
+   */
+  abstract get description(): string
+}
+
+/**
+ * Organization event.
+ */
+export enum OrganizationEvent {
+  ADDED = 'added',
+  REMOVED = 'removed',
+  CHANGED = 'changed',
+  CURRENT_CHANGED = 'currentChanged'
+}
+
+/**
+ * Organizations storage.
+ */
+export abstract class Organizations extends EventDispatcher<
+  OrganizationEvent,
+  Organization | Organizations
+> {
+  /**
+   * User's organizations.
+   */
+  abstract get collection(): ReadonlyArray<Organization>
+
+  /**
+   * Current organization.
+   */
+  abstract get current(): OrganizationId
+  abstract set current(value: OrganizationId)
+
+  /**
+   * Get organization by id.
+   */
+  abstract get(id: OrganizationId): Organization
+
+  /**
+   * Try to get organization by id.
+   * @param id
+   */
+  abstract tryGet(id: OrganizationId): Organization | undefined
+
+  /**
+   * Create new organization.
+   */
+  abstract create(name: string, description: string): Promise<Organization>
+
+  /**
+   * Delete organization.
+   */
+  abstract delete(id: OrganizationId): Promise<void>
+}

package/src/storages/userProfile.ts

@@ -0,0 +1,42 @@
+import { EventDispatcher } from '../events'
+
+export type UserId = string
+
+export enum UserEvent {
+  CHANGED = 'changed'
+}
+
+export abstract class UserProfile extends EventDispatcher<
+  UserEvent,
+  UserProfile
+> {
+  /**
+   * User id.
+   */
+  abstract get id(): UserId
+
+  /**
+   * User name.
+   */
+  abstract get name(): string
+
+  /**
+   * User email.
+   */
+  abstract get email(): string
+
+  /**
+   * Is user deleted.
+   */
+  abstract get isDeleted(): boolean
+
+  /**
+   * Created at.
+   */
+  abstract get createdAt(): Date
+
+  /**
+   * Modified at.
+   */
+  abstract get modifiedAt(): Date
+}