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

package/README.md

@@ -1,7 +1,96 @@
 # DataIsland Client SDK
 
-```typescript
+The DataIsland Client SDK is a TypeScript library designed to seamlessly integrate DataIsland web services into websites.
 
+## Table of contents
 
+1. [Connect](#connect)
+2. [Create app](#create-app)
+3. [Use organizations](#use-organizations)
+4. [Use chat](#use-chat)
+5. [Use workspaces](#use-workspaces)
+6. [Use files](#use-files)
+7. [Use access groups](#use-access-groups)
+8. [Use invites](#use-invites)
 
-```
+### Connect
+
+For connecting this library to your website project simply install it using npm package manager.
+
+`npm i @neuralinnovations/dataisland-sdk`
+
+### Create app
+
+You can initialize default app sdk instance using this code example.
+
+```
+const app = await appSdk("your-app-name", async (builder: AppBuilder) => {
+    builder.useHost(HOST)
+    builder.useCredential(new BearerCredential(TOKEN))
+  })
+```
+
+It is immpossible to create more than one app sdk intance with same name.
+
+**HOST** is a DataIsland API url which can be passed using environment file.
+
+Second required parameter for builder is Credentials. It is recomended to use Bearer credentials instance and pass your user Auth0 **TOKEN** in order to get access to API.
+
+You can also add requests middlewares with builder options.
+
+```
+const app = await appSdk("your-app-name", async (builder: AppBuilder) => {
+      builder.useHost(YOUR_HOST)
+      builder.useAutomaticDataCollectionEnabled(false)
+      builder.useCredential(new BasicCredential("email", "password"))
+      builder.registerMiddleware(async (req, next) => {
+        req.headers.set("Your-header-name", "value")
+        return await next(req)
+      })
+    })
+```
+
+### Use organizations
+
+Organization is a top data structure object, which represents a company or some group of people using our services.
+It contains of users ( admin or regular ), workspaces with files ( folders with access control features ) and chats.
+
+By default all user organizations are fetched with user profile during app sdk start. But if there are no organizations linked to the user, you should run Create organization flow. This flow requires organization name and description data, and also first workspace name and description data provided by user.
+
+**NOTE** There are two types of DataIsland web api servers, public and private. On public servers users can create their own organization after first registration, on private servers you must register using invite links.
+
+Default organization creation code example:
+
+```
+// create organization
+  const org = await app.organizations.create(
+    "your-organization-name",
+    "your-organization-description"
+  )
+```
+
+### Use workspaces
+
+Workspaces are folder-like objects used to store files and controll access to it using acces groups. During creation you must pass organization Id, name and description of new workspace and regulation options. You can pass existing group ID or ask to create new group for this workspace in regulation section. 
+
+Default workspace creation example:
+
+```
+const wsPromise = org.workspaces.create(
+      "your-workspace-name",
+      "your-workspace-description",
+      regulation: {
+        isCreateNewGroup: boolean - "Bool option for new group creation"
+        newGroupName: string - "New group name"
+        groupIds: string[] - "Array of selected accessed groups IDs"
+      }
+    )
+```
+
+### Use files
+
+### Use chat
+
+### Use access groups
+
+### Use Invites

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralinnovations/dataisland-sdk",
-  "version": "0.0.1-dev3",
+  "version": "0.0.1-dev4",
   "description": "SDK for DataIsland project",
   "licenses": [
     {

package/src/disposable.ts

@@ -9,7 +9,8 @@ export interface Disposable {
  * Represents a lifetime.
  */
 export class Lifetime {
-  constructor(private readonly container: DisposableContainer) {}
+  constructor(private readonly container: DisposableContainer) {
+  }
 
   /**
    * Define a new nested disposable to this lifetime.
@@ -147,5 +148,3 @@ export function disposable(action: () => void, target: unknown): Disposable {
     action.call(target)
   })
 }
-
-export const eternalLifetime = new DisposableContainer().lifetime

package/src/dto/workspacesResponse.ts

@@ -1,5 +1,5 @@
 import { WorkspaceId } from "../storages/workspaces"
-import { FileId } from "../storages/files"
+import { FileId } from "../storages/file"
 
 export interface WorkspaceProfileDto {
   name: string
@@ -26,7 +26,7 @@ export interface FileProgressDto {
   file_parts_count: number
   completed_parts_count: number
   success: boolean
-  error: string
+  error?: string
 }
 
 export interface FileDto {

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

@@ -7,6 +7,17 @@ export * from "./events"
 export * from "./disposable"
 export * from "./credentials"
 export * from "./appSdk"
+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"
 
 const _appsNotReady = new Map<string, Promise<AppSdk>>()
 const _appsReady = new Map<string, AppSdk>()
@@ -73,3 +84,6 @@ export async function appSdk(
   }
   return await appPromise
 }
+
+export { File } from "./storages/file"
+export { FilesPage } from "./storages/filesPage"

package/src/internal/app.impl.ts

@@ -104,13 +104,6 @@ export class AppImplementation extends AppSdk {
       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)
-    })
-
     // call customer setup
     if (setup !== undefined) {
       await setup(builder)
@@ -154,7 +147,9 @@ export class AppImplementation extends AppSdk {
     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,7 +162,9 @@ 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

package/src/services/middlewareService.ts

@@ -3,7 +3,7 @@ import { type Middleware } from "../middleware"
 import { type Disposable } from "../disposable"
 
 export class MiddlewareService extends Service {
-  _middlewares: Middleware[] = []
+  private _middlewares: Middleware[] = []
 
   public useMiddleware(middleware: Middleware): Disposable {
     this._middlewares.push(middleware)

package/src/services/requestBuilder.ts

@@ -48,18 +48,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
+    })
+
+    // 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 | null | undefined = null
     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 +109,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 | null | undefined = null
     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/rpcService.ts

@@ -14,6 +14,7 @@ export interface RequestOptions {
  * RPC service.
  */
 export class RpcService extends Service {
+
   constructor(
     serviceContext: ServiceContext,
     /**
@@ -32,6 +33,22 @@ export class RpcService extends Service {
     }
   ) {
     super(serviceContext)
+
+    serviceContext.onRegister = async () => {
+      serviceContext.resolve(MiddlewareService)?.useMiddleware((req, next) => {
+        if (!req.headers.has("accept")) {
+          req.headers.set("accept", "text/plain")
+        }
+
+        if ((req as any).discardContentType) {
+          delete (req as any).discardContentType
+        } else {
+          req.headers.set("content-type", "application/json")
+        }
+
+        return next(req)
+      })
+    }
   }
 
   /**
@@ -87,35 +104,35 @@ export class RpcService extends Service {
   /**
    * Send a POST request.
    * @param path
-   * @param body
+   * @param body JSON object
    * @param options
    */
   async post(
     path: string,
-    body?: BodyInit | null,
+    body: object | null | undefined,
     options?: RequestOptions
   ): Promise<Response> {
     return this.requestBuilder(path)
       .searchParams(options?.searchParams)
       .headers(options?.headers)
-      .sendPost(body)
+      .sendPostJson(body)
   }
 
   /**
    * Send a PUT request.
    * @param path
-   * @param body
+   * @param body JSON object
    * @param options
    */
   async put(
     path: string,
-    body?: BodyInit | null,
+    body: object | null | undefined,
     options?: RequestOptions
   ): Promise<Response> {
     return this.requestBuilder(path)
       .searchParams(options?.searchParams)
       .headers(options?.headers)
-      .sendPut(body)
+      .sendPutJson(body)
   }
 
   /**

package/src/services/service.ts

@@ -6,7 +6,8 @@ export class ServiceContext {
   constructor(
     public readonly context: Context,
     private readonly disposableContainer: DisposableContainer
-  ) {}
+  ) {
+  }
 
   public get lifetime(): Lifetime {
     return this.disposableContainer.lifetime
@@ -16,15 +17,15 @@ export class ServiceContext {
     return this.context.resolve(type)
   }
 
-  public async onRegister(): Promise<void> {
+  public onRegister: () => Promise<void> = async (): Promise<void> => {
     await Promise.resolve()
   }
 
-  public async onStart(): Promise<void> {
+  public onStart: () => Promise<void> = async (): Promise<void> => {
     await Promise.resolve()
   }
 
-  public onUnregister(): void {
+  public onUnregister: () => void = (): void => {
     // do nothing
   }
 }
@@ -42,5 +43,6 @@ export abstract class Service {
     return this.serviceContext.context
   }
 
-  public constructor(private readonly serviceContext: ServiceContext) {}
+  public constructor(private readonly serviceContext: ServiceContext) {
+  }
 }

package/src/storages/chat.ts

@@ -1,12 +1,5 @@
-import { EventDispatcher } from "../events"
-
 export type ChatId = string
 
-export enum ChatsEvent {
-  ADDED = "added",
-  REMOVED = "removed"
-}
-
 export enum ChatAnswer {
   SHORT = "short",
   LONG = "long"
@@ -26,12 +19,3 @@ export abstract class Chat {
   abstract question(message: string, answer?: ChatAnswer): Promise<void>
 }
 
-/**
- * Chats storage.
- */
-export abstract class Chats extends EventDispatcher<ChatsEvent, Chat> {
-  /**
-   * Create new chat.
-   */
-  abstract create(): Promise<Chat>
-}

package/src/storages/chats.ts

@@ -0,0 +1,17 @@
+import { EventDispatcher } from "../events"
+import { Chat } from "./chat"
+
+export enum ChatsEvent {
+  ADDED = "added",
+  REMOVED = "removed"
+}
+
+/**
+ * Chats storage.
+ */
+export abstract class Chats extends EventDispatcher<ChatsEvent, Chat> {
+  /**
+   * Create new chat.
+   */
+  abstract create(): Promise<Chat>
+}

package/src/storages/file.impl.ts

@@ -2,8 +2,8 @@ import { Context } from "../context"
 import { Disposable } from "../disposable"
 import { FileDto, FileProgressDto } from "../dto/workspacesResponse"
 import { RpcService } from "../services/rpcService"
-import { File } from "./files"
 import { ResponseUtils } from "../services/responseUtils"
+import { File } from "./file"
 
 export class FileImpl extends File implements Disposable {
   private _isDisposed: boolean = false
@@ -32,7 +32,7 @@ export class FileImpl extends File implements Disposable {
   }
 
   get name(): string {
-    return <string>this._content?.id
+    return <string>this._content?.name
   }
 
   async url(): Promise<string> {
@@ -55,7 +55,7 @@ export class FileImpl extends File implements Disposable {
   async status(): Promise<FileProgressDto> {
     const response = await this.context
       .resolve(RpcService)
-      ?.requestBuilder("api/v1/Files/url")
+      ?.requestBuilder("api/v1/Files/fetch")
       .searchParam("id", this.id)
       .sendGet()
 
@@ -63,6 +63,7 @@ export class FileImpl extends File implements Disposable {
       await ResponseUtils.throwError(`Failed to get file ${this.id}`, response)
     }
 
-    return (await response!.json()).progress as FileProgressDto
+    const content = await response!.json()
+    return content.progress as FileProgressDto
   }
 }

package/src/storages/file.ts

@@ -0,0 +1,28 @@
+import { FileProgressDto } from "../dto/workspacesResponse"
+
+export type FileId = string
+
+/**
+ * File.
+ */
+export abstract class File {
+  /**
+   * File id.
+   */
+  abstract get id(): FileId
+
+  /**
+   * File name.
+   */
+  abstract get name(): string
+
+  /**
+   * Get temporary url.
+   */
+  abstract url(): Promise<string>
+
+  /**
+   * Get file status.
+   */
+  abstract status(): Promise<FileProgressDto>
+}

package/src/storages/files.impl.ts

@@ -1,12 +1,13 @@
 import { Context } from "../context"
 import { Disposable } from "../disposable"
 import { FileDto, FileListResponse } from "../dto/workspacesResponse"
-import { OrganizationService } from "../services/organizationService"
 import { RpcService } from "../services/rpcService"
 import { FileImpl } from "./file.impl"
-import { File, Files, FilesEvent, FilesList as FilesPage } from "./files"
+import { Files, FilesEvent, UploadFile } from "./files"
 import { WorkspaceImpl } from "./workspace.impl"
 import { ResponseUtils } from "../services/responseUtils"
+import { File } from "./file"
+import { FilesPage } from "./filesPage"
 
 export class FilesPageImpl extends FilesPage implements Disposable {
   private _isDisposed: boolean = false
@@ -100,9 +101,16 @@ export class FilesImpl extends Files {
     page: number,
     limit: number
   ): Promise<FilesPage> {
+
+    // check page
     if (page === undefined || page === null) {
       throw new Error("File fetch, page is undefined or null")
     }
+    if (page < 0) {
+      throw new Error("File fetch, page is negative")
+    }
+
+    // check limit
     if (limit === undefined || limit === null) {
       throw new Error("File fetch, limit is undefined or null")
     }
@@ -110,23 +118,19 @@ export class FilesImpl extends Files {
       throw new Error("File fetch, limit is 0")
     }
 
-    const orgService = this.context.resolve(OrganizationService)
-
-    if (orgService === undefined) {
-      throw new Error("File fetch, organization service undefined")
-    }
-
+    // send request to the server
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/Files/list")
 
       .searchParam("workspaceId", this.workspace.id)
-      .searchParam("organizationId", orgService.organizations.current)
+      .searchParam("organizationId", this.workspace.organization.id)
       .searchParam("query", query)
       .searchParam("page", page.toString())
       .searchParam("limit", limit.toString())
       .sendGet()
 
+    // check response status
     if (ResponseUtils.isFail(response)) {
       await ResponseUtils.throwError(
         `Files fetch query:${query}, page:${page}, limit:${limit}, failed`,
@@ -134,57 +138,74 @@ export class FilesImpl extends Files {
       )
     }
 
+    // parse files from the server's response
     const files = (await response!.json()) as FileListResponse
 
+    // create files list
     const filesList = new FilesPageImpl()
     filesList.total = files.totalFilesCount
     filesList.filesPerPage = files.filesPerPage
     filesList.page = page
+
+    // init files from the server's response
     for (const fl of files.files) {
+
+      // create file implementation
       const file = new FileImpl(this.context).initFrom(fl)
 
+      // add file to the collection
       filesList.files.push(file)
 
+      // dispatch event, file added
       this.dispatch({
         type: FilesEvent.ADDED,
         data: file
       })
     }
 
+    // set files list
     this.filesList = filesList
 
     return filesList
   }
 
-  async internalUpload(file: any): Promise<File> {
-    const orgService = this.context.resolve(OrganizationService)
-
-    if (orgService === undefined) {
-      throw new Error("File load, organization service undefined")
+  async internalUpload(file: UploadFile): Promise<File> {
+    // check file
+    if (file === undefined || file === null) {
+      throw new Error("File upload, file is undefined or null")
     }
 
+    // form data to send
     const form = new FormData()
-    form.append("organizationId", orgService.organizations.current)
+    form.append("organizationId", this.workspace.organization.id)
     form.append("workspaceId", this.workspace.id)
     form.append("name", file.name)
     form.append("file", file, file.name)
 
+    // send request to the server
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/Files")
-      .sendPost(form)
+      .sendPostFormData(form)
+
+    // check response status
     if (ResponseUtils.isFail(response)) {
-      await ResponseUtils.throwError(`File upload ${file}`, response)
+      await ResponseUtils.throwError(`File upload ${file.name}`, response)
     }
+
+    // parse file from the server's response
     const result = (await response!.json()).file as FileDto
 
+    // create file implementation
     const fileImpl = new FileImpl(this.context).initFrom(result)
 
-    this.filesList!.files.push(file)
+    // TODO: why is this here?
+    this.filesList?.files.push(fileImpl)
 
+    // dispatch event, file added
     this.dispatch({
       type: FilesEvent.ADDED,
-      data: file
+      data: fileImpl
     })
 
     return fileImpl

package/src/storages/files.ts

@@ -1,39 +1,19 @@
-import { FileProgressDto } from '../dto/workspacesResponse'
-import { EventDispatcher } from '../events'
-
-export type FileId = string
+import { EventDispatcher } from "../events"
+import { File, FileId } from "./file"
+import { FilesPage } from "./filesPage"
 
+/**
+ * Files event.
+ */
 export enum FilesEvent {
-  ADDED = 'added',
-  REMOVED = 'removed'
+  ADDED = "added",
+  REMOVED = "removed"
 }
 
-export type UploadFile = File | Blob | string
-
 /**
- * File.
+ * Upload file.
  */
-export abstract class File {
-  /**
-   * File id.
-   */
-  abstract get id(): FileId
-
-  /**
-   * File name.
-   */
-  abstract get name(): string
-
-  /**
-   * Get temporary url.
-   */
-  abstract url(): Promise<string>
-
-  /**
-   * Get file status.
-   */
-  abstract status(): Promise<FileProgressDto>
-}
+export type UploadFile = globalThis.File
 
 /**
  * Files storage.
@@ -42,7 +22,7 @@ export abstract class Files extends EventDispatcher<FilesEvent, File> {
   /**
    * Get file by id.
    */
-  abstract upload(file: any): Promise<File>
+  abstract upload(file: UploadFile): Promise<File>
 
   /**
    * Delete file.
@@ -53,15 +33,6 @@ export abstract class Files extends EventDispatcher<FilesEvent, File> {
   /**
    * Query files.
    */
-  abstract query(query: string, page: number, limit: number): Promise<FilesList>
+  abstract query(query: string, page: number, limit: number): Promise<FilesPage>
 }
 
-export abstract class FilesList {
-  abstract get files(): File[]
-
-  abstract get pages(): number
-
-  abstract get total(): number
-
-  abstract get page(): number
-}

package/src/storages/filesPage.ts

@@ -0,0 +1,27 @@
+import { File } from "./file"
+
+/**
+ * Files page.
+ */
+export abstract class FilesPage {
+
+  /**
+   * Get files.
+   */
+  abstract get files(): File[]
+
+  /**
+   * Get pages count.
+   */
+  abstract get pages(): number
+
+  /**
+   * Get total count.
+   */
+  abstract get total(): number
+
+  /**
+   * Get current page.
+   */
+  abstract get page(): number
+}

package/src/storages/groups.impl.ts

@@ -73,12 +73,12 @@ export class GroupImpl extends Group implements Disposable {
       } catch (e) {
         console.error(e)
       }
-  
+
       throw new Error(
         `Groups get workspaces, response is not ok, status: ${response?.status},${response?.statusText} ${text}`
       )
     }
-  
+
     const workspaces = (await response.json()) as WorkspacesResponse
 
     return workspaces.workspaces
@@ -101,7 +101,7 @@ export class GroupImpl extends Group implements Disposable {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/AccessGroups/name")
-      .sendPut({
+      .sendPutJson({
         groupId: this.id,
         name: name
       })
@@ -117,7 +117,7 @@ export class GroupImpl extends Group implements Disposable {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/AccessGroups/permits")
-      .sendPut({
+      .sendPutJson({
         groupId: this.id,
         permits: permits
       })
@@ -138,7 +138,7 @@ export class GroupImpl extends Group implements Disposable {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/AccessGroups/workspaces")
-      .sendPut({
+      .sendPutJson({
         groupId: this.id,
         actualWorkspaceIds: workspaces
       })
@@ -159,7 +159,7 @@ export class GroupImpl extends Group implements Disposable {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/AccessGroups/members")
-      .sendPut({
+      .sendPutJson({
         groupId: this.id,
         memberIds: members
       })
@@ -227,12 +227,12 @@ export class GroupsImpl extends Groups {
       } catch (e) {
         console.error(e)
       }
-  
+
       throw new Error(
         `Groups init, response is not ok, status: ${response?.status},${response?.statusText} ${text}`
       )
     }
-  
+
     const groups = (await response.json()) as AccessGroupsResponse
 
     for (const gr of groups.groups){
@@ -258,7 +258,7 @@ export class GroupsImpl extends Groups {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/AccessGroups")
-      .sendPost({
+      .sendPostJson({
         name: name,
         organizationId: organizationId,
         permits: permits,
@@ -333,5 +333,5 @@ export class GroupsImpl extends Groups {
     group.dispose()
   }
 
-    
+
 }

package/src/storages/organizations.impl.ts

@@ -130,7 +130,7 @@ export class OrganizationsImpl extends Organizations {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/Organizations")
-      .sendPost({
+      .sendPostJson({
         profile: {
           name: name,
           description: description

package/src/storages/workspace.impl.ts

@@ -72,7 +72,7 @@ export class WorkspaceImpl extends Workspace {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/Workspaces")
-      .sendPut({
+      .sendPutJson({
         workspaceId: this.id,
         profile: {
           name,

package/src/storages/workspace.ts

@@ -1,6 +1,7 @@
 import { EventDispatcher } from "../events"
 import { Files } from "./files"
 import { WorkspaceId } from "./workspaces"
+import { Organization } from "./organization"
 
 /**
  * Workspace event.
@@ -16,6 +17,11 @@ export abstract class Workspace extends EventDispatcher<
   WorkspaceEvent,
   Workspace
 > {
+  /**
+   * Organization.
+   */
+  abstract get organization(): Organization
+
   /**
    * Workspace id.
    */

package/src/storages/workspaces.impl.ts

@@ -87,7 +87,7 @@ export class WorkspacesImpl extends Workspaces {
     const response = await this.context
       .resolve(RpcService)
       ?.requestBuilder("api/v1/Workspaces")
-      .sendPost({
+      .sendPostJson({
         organizationId: this.organization.id,
         profile: {
           name: name,

package/test/files.test.ts

@@ -0,0 +1,52 @@
+import fs from "fs"
+import { testInWorkspace } from "./setup"
+
+test("Files", async () => {
+  await testInWorkspace(async (app, org, ws) => {
+
+    expect(app).not.toBeUndefined()
+    expect(org).not.toBeUndefined()
+
+    const buffer = fs.readFileSync("test/data/test_file.pdf")
+    const file_obj = new File([new Uint8Array(buffer)], "test_file.pdf", {
+      type: "application/pdf"
+    })
+
+    const filePromise = ws.files.upload(file_obj)
+    await expect(filePromise).resolves.not.toThrow()
+    const file = await filePromise
+
+    expect(file).not.toBeUndefined()
+    expect(file).not.toBeNull()
+    expect(file.name).toBe("test_file.pdf")
+
+    let status = await file.status()
+
+    expect(status).not.toBeUndefined()
+    expect(status).not.toBeNull()
+    if (!status.success && status.error) {
+      console.error(status.error)
+    }
+    expect(status.success).toBe(true)
+    expect(status.file_id).toBe(file.id)
+    expect(status.file_parts_count).toBeGreaterThanOrEqual(status.completed_parts_count)
+
+    while (
+      status.success &&
+      status.completed_parts_count !== status.file_parts_count
+    ) {
+      await new Promise(r => setTimeout(r, 1000))
+      status = await file.status()
+    }
+
+    const queryPromise = ws.files.query("", 0, 20)
+    await expect(queryPromise).resolves.not.toThrow()
+    const filePage = await queryPromise
+    expect(filePage).not.toBeUndefined()
+    expect(filePage).not.toBeNull()
+    expect(filePage.files.length).toBe(1)
+    expect(filePage.pages).toBe(1)
+
+    await expect(ws.files.delete(file.id)).resolves.not.toThrow()
+  })
+})

package/test/index.test.ts

@@ -12,9 +12,7 @@ import { CredentialService } from "../src/services/credentialService"
 import { RpcService } from "../src/services/rpcService"
 import { AppBuilder } from "../src/appBuilder"
 import { UnitTest, AppSdkUnitTest } from "../src/unitTest"
-import { HOST, TOKEN } from "./setup"
-import { OrganizationImpl } from "../src/storages/organization.impl"
-import * as fs from "fs"
+import { HOST, randomHash, TOKEN } from "./setup"
 
 test("SDK_VERSION", () => {
   expect(SDK_VERSION).toBe(version)
@@ -29,110 +27,6 @@ test("Default SDK", async () => {
   expect(app).not.toBeUndefined()
 })
 
-test("Create and delete organization, create and delete workspace", async () => {
-  const randomName = `org-test-${Math.random().toString(16)}`
-  const app = await appSdk(randomName, async builder => {
-    builder.useHost(HOST)
-    builder.useCredential(new DebugCredential(TOKEN))
-  })
-
-  const initLength = app.organizations.collection.length
-
-  const org = await app.organizations.create(
-    randomName,
-    "this is a unitTest description"
-  )
-
-  // check organization
-  expect(org).not.toBeUndefined()
-  expect(org).not.toBeNull()
-  expect(org).toBeInstanceOf(OrganizationImpl)
-
-  expect(org.id).not.toBeUndefined()
-  expect(org.id).not.toBeNull()
-  expect(org.id.trim()).not.toBe("")
-
-  // check name
-  expect(org.name).not.toBeUndefined()
-  expect(org.name).not.toBeNull()
-  expect(org.name.trim()).not.toBe("")
-
-  // check description
-  expect(org.description).not.toBeUndefined()
-  expect(org.description).not.toBeNull()
-  expect(org.description.trim()).not.toBe("")
-
-  // check organizations
-  expect(app.organizations.get(org.id)).toBe(org)
-  expect(app.organizations.tryGet(org.id)).toBe(org)
-  expect(app.organizations.collection.length).toBe(initLength + 1)
-
-  const initWorkspacesLength = org.workspaces.collection.length
-
-  const wsPromise = org.workspaces.create(
-    "test-workspace",
-    "test-workspace-description"
-  )
-  await expect(wsPromise).resolves.not.toThrow()
-  const ws = await wsPromise
-  expect(ws).not.toBeUndefined()
-  expect(ws).not.toBeNull()
-  expect(ws.name).toBe("test-workspace")
-  expect(ws.description).toBe("test-workspace-description")
-  expect(app.organizations.get(org.id).workspaces.collection.length).toBe(
-    initWorkspacesLength + 1
-  )
-  expect(org.workspaces.collection.length).toBe(initWorkspacesLength + 1)
-  expect(org.workspaces.get(ws.id)).toBe(ws)
-  expect(org.workspaces.tryGet(ws.id)).toBe(ws)
-  expect(org.workspaces.contains(ws.id)).toBe(true)
-
-  const buffer = fs.readFileSync("test_file.pdf")
-  const file_obj = new File([new Uint8Array(buffer)], "test_file.pdf", {
-    type: "text/plain"
-  })
-
-  const filePromise = ws.files.upload(file_obj)
-  await expect(filePromise).resolves.not.toThrow()
-  const file = await filePromise
-
-  expect(file).not.toBeUndefined()
-  expect(file).not.toBeNull()
-  expect(file.name).toBe("test_file.pdf")
-
-  let status = await file.status()
-
-  expect(status).not.toBeUndefined()
-  expect(status).not.toBeNull()
-  expect(status.file_id).toBe(file.id)
-  expect(status.file_parts_count).toBeGreaterThan(status.completed_parts_count)
-
-  while (
-    status.success == true &&
-    status.completed_parts_count !== status.file_parts_count
-  ) {
-    await new Promise(r => setTimeout(r, 1000))
-    status = await file.status()
-  }
-
-  const queryPromise = ws.files.query("", 0, 20)
-  await expect(queryPromise).resolves.not.toThrow()
-  const filePage = await queryPromise
-  expect(filePage).not.toBeUndefined()
-  expect(filePage).not.toBeNull()
-  expect(filePage.files.length).toBe(1)
-  expect(filePage.pages).toBe(1)
-
-  await expect(ws.files.delete(file.id)).resolves.not.toThrow()
-
-  await expect(org.workspaces.delete(ws.id)).resolves.not.toThrow()
-
-  await expect(app.organizations.delete(org.id)).resolves.not.toThrow()
-  expect((<OrganizationImpl>org).isDisposed).toBe(true)
-  expect(app.organizations.collection.length).toBe(initLength)
-  expect(app.organizations.tryGet(org.id)).toBeUndefined()
-})
-
 test("SDK, middleware", async () => {
   await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
     const app = await appSdk("test-settings", async (builder: AppBuilder) => {
@@ -203,10 +97,12 @@ test("SDK, it is impossible to setup the same application", async () => {
     // this test is not stable if you run all tests at once
     // because the app is cached all app instances
     // we use a random identifier every time
-    const testId = Math.random().toString(16)
-    const promise = appSdk(`test-setup-${testId}`).then(() => {})
+    const testId = `test-setup-${randomHash()}`
+    const promise = appSdk(testId).then(() => {
+    })
     await expect(
-      appSdk(`test-setup-${testId}`, async () => {})
+      appSdk(testId, async () => {
+      })
     ).rejects.toThrow()
     await promise
   })
@@ -217,9 +113,10 @@ test("SDK, setup and get this app", async () => {
     // this test is not stable if you run all tests at once
     // because the app is cached all app instances
     // we use a random identifier every time
-    const testId = Math.random().toString(16)
-    const promise = appSdk(`test-get-${testId}`).then(() => {})
-    await expect(appSdk(`test-get-${testId}`)).resolves.toBeInstanceOf(AppSdk)
+    const testId = `test-get-${randomHash()}`
+    const promise = appSdk(testId).then(() => {
+    })
+    await expect(appSdk(testId)).resolves.toBeInstanceOf(AppSdk)
     await promise
   })
 })

package/test/organization.test.ts

@@ -0,0 +1,57 @@
+import { appSdk, DebugCredential } from "../src"
+import { HOST, randomHash, TOKEN } from "./setup"
+import { OrganizationImpl } from "../src/storages/organization.impl"
+
+test("Organization", async () => {
+  // make random name
+  const randomName = `org-test-${randomHash()}`
+
+  // create app
+  const app = await appSdk(randomName, async builder => {
+    builder.useHost(HOST)
+    builder.useCredential(new DebugCredential(TOKEN))
+  })
+
+  // save init length
+  const initLength = app.organizations.collection.length
+
+  // create organization
+  const org = await app.organizations.create(
+    randomName,
+    "this is a unitTest description"
+  )
+
+  // check organization
+  expect(org).not.toBeUndefined()
+  expect(org).not.toBeNull()
+  expect(org).toBeInstanceOf(OrganizationImpl)
+
+  expect(org.id).not.toBeUndefined()
+  expect(org.id).not.toBeNull()
+  expect(org.id.trim()).not.toBe("")
+
+  // check name
+  expect(org.name).not.toBeUndefined()
+  expect(org.name).not.toBeNull()
+  expect(org.name.trim()).not.toBe("")
+
+  // check description
+  expect(org.description).not.toBeUndefined()
+  expect(org.description).not.toBeNull()
+  expect(org.description.trim()).not.toBe("")
+
+  // check organizations
+  expect(app.organizations.get(org.id)).toBe(org)
+  expect(app.organizations.tryGet(org.id)).toBe(org)
+  expect(app.organizations.collection.length).toBe(initLength + 1)
+
+  // delete organization
+  await expect(app.organizations.delete(org.id)).resolves.not.toThrow()
+  expect((<OrganizationImpl>org).isDisposed).toBe(true)
+
+  // check init length
+  expect(app.organizations.collection.length).toBe(initLength)
+
+  // check organization must be undefined because it was deleted
+  expect(app.organizations.tryGet(org.id)).toBeUndefined()
+})

package/test/setup.ts

@@ -1,2 +1,54 @@
+import { appSdk, AppSdk, DebugCredential } from "../src"
+import { Organization } from "../src/storages/organization"
+import { Workspace } from "../src/storages/workspace"
+
 export const HOST = <string>process.env.HOST
 export const TOKEN = <string>process.env.TOKEN
+
+export const randomHash = (length: number = 5) => {
+  if (length <= 0) length = 1
+  return `name-${((Math.random() * Math.pow(10, length)) | 0).toString(16)}`
+}
+
+export const testInOrganization = async (func: (app: AppSdk, org: Organization) => Promise<void>, config ?: {
+    host: string,
+    token: string
+  }
+): Promise<void> => {
+  const randomName = `org-name-${randomHash()}`
+  const app = await appSdk(randomName, async builder => {
+    builder.useHost(config?.host ?? HOST)
+    builder.useCredential(new DebugCredential(config?.token ?? TOKEN))
+  })
+  const org = await app.organizations.create(
+    randomName,
+    "this is a unitTest description"
+  )
+  try {
+    await func(app, org)
+  } finally {
+    if (app
+      .organizations.tryGet(org.id)
+    ) {
+      await app.organizations.delete(org.id)
+    }
+  }
+}
+
+export const testInWorkspace = async (func: (app: AppSdk, org: Organization, workspace: Workspace)
+  => Promise<void>, config?: {
+  host: string,
+  token: string,
+}): Promise<void> => {
+  await testInOrganization(async (app, org) => {
+    const randomName = `workspace-${randomHash()}`
+    const workspace = await org.workspaces.create(randomName, `description of ${randomName}`)
+    try {
+      await func(app, org, workspace)
+    } finally {
+      if (org.workspaces.tryGet(workspace.id)) {
+        await org.workspaces.delete(workspace.id)
+      }
+    }
+  }, config)
+}

package/test/workspace.test.ts

@@ -0,0 +1,71 @@
+import { testInOrganization, testInWorkspace } from "./setup"
+
+test("Workspace create / delete", async () => {
+  await testInOrganization(async (app, org) => {
+    // save init length
+    const initWorkspaceCount = org.workspaces.collection.length
+
+    // create workspace
+    const wsPromise = org.workspaces.create(
+      "test-workspace",
+      "test-workspace-description"
+    )
+
+    // check not throw
+    await expect(wsPromise).resolves.not.toThrow()
+
+    // get workspace
+    const ws = await wsPromise
+
+    // check exists
+    expect(ws).not.toBeUndefined()
+
+    // check exists
+    expect(ws).not.toBeNull()
+
+    // check name
+    expect(ws.name).toBe("test-workspace")
+
+    // check description
+    expect(ws.description).toBe("test-workspace-description")
+
+    // check collection length
+    expect(app.organizations.get(org.id).workspaces.collection.length).toBe(
+      initWorkspaceCount + 1
+    )
+
+    // check collection length
+    expect(org.workspaces.collection.length).toBe(initWorkspaceCount + 1)
+
+    // check get
+    expect(org.workspaces.get(ws.id)).toBe(ws)
+
+    // check tryGet
+    expect(org.workspaces.tryGet(ws.id)).toBe(ws)
+
+    // check contains
+    expect(org.workspaces.contains(ws.id)).toBe(true)
+
+    // check delete
+    await expect(org.workspaces.delete(ws.id)).resolves.not.toThrow()
+  })
+})
+
+test("Workspace, change", async () => {
+  await testInWorkspace(async (app, org, ws) => {
+
+    expect(ws.name).not.toBe("new-name")
+
+    // rename
+    await ws.change("new-name", "new-description")
+
+    // check name
+    expect(ws.name).toBe("new-name")
+
+    // check description
+    expect(ws.description).toBe("new-description")
+
+    // check name
+    expect(ws.name).toBe("new-name")
+  })
+})