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

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/src/unitTest.ts

@@ -9,7 +9,7 @@ export enum UnitTest {
 export type UnitTestProfileSyncAction = () => void
 export type UnitTestProfileAsyncAction = () => Promise<void>
 
-export class AppSdkUnitTest {
+class AppSdkUnitTest {
   private static _stack: UnitTest[] = [UnitTest.DO_NOTHING]
 
   public static get current(): UnitTest {
@@ -37,6 +37,17 @@ export class AppSdkUnitTest {
   }
 }
 
+export const appTest = async (
+  unitTest: UnitTest = UnitTest.DEFAULT,
+  func: UnitTestProfileSyncAction | UnitTestProfileAsyncAction
+): Promise<void> => {
+  await AppSdkUnitTest.test(unitTest, func)
+}
+
+export const appTestCurrent = (): UnitTest => {
+  return AppSdkUnitTest.current
+}
+
 export const isUnitTest = (mask: UnitTest): boolean => {
   return (AppSdkUnitTest.current & mask) == mask
 }

package/test/commands.test.ts

@@ -1,6 +1,6 @@
 import { Command, CommandHandler } from "../src/services/commandService"
-import { appSdk } from "../src"
-import { UnitTest, AppSdkUnitTest } from "../src/unitTest"
+import { dataIslandApp } from "../src"
+import { appTest, UnitTest } from "../src/unitTest"
 
 class Cmd extends Command {
   constructor(public readonly name: string = "test") {
@@ -15,8 +15,8 @@ class CmdHandler extends CommandHandler<Cmd> {
 }
 
 test("Commands test", async () => {
-  await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
-    const app = await appSdk("test-commands", async builder => {
+  await appTest(UnitTest.DEFAULT, async () => {
+    const app = await dataIslandApp("test-commands", async builder => {
       builder.registerCommand(Cmd, context => new CmdHandler(context))
     })
     expect(app.context.execute(new Cmd("test-command"))).toBeDefined()

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

@@ -1,8 +1,8 @@
 import { version } from "../package.json"
 import {
-  AppSdk,
+  DataIslandApp,
   BasicCredential,
-  appSdk,
+  dataIslandApp,
   SDK_VERSION,
   DEFAULT_NAME,
   DebugCredential
@@ -11,10 +11,8 @@ import { MiddlewareService } from "../src/services/middlewareService"
 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 { UnitTest, appTest } from "../src/unitTest"
+import { HOST, randomHash, TOKEN } from "./setup"
 
 test("SDK_VERSION", () => {
   expect(SDK_VERSION).toBe(version)
@@ -22,120 +20,16 @@ test("SDK_VERSION", () => {
 
 test("Default SDK", async () => {
   // default
-  const app = await appSdk(DEFAULT_NAME, async (builder: AppBuilder) => {
+  const app = await dataIslandApp(DEFAULT_NAME, async (builder: AppBuilder) => {
     builder.useHost(HOST)
     builder.useCredential(new DebugCredential(TOKEN))
   })
   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) => {
+  await appTest(UnitTest.DEFAULT, async () => {
+    const app = await dataIslandApp("test-settings", async (builder: AppBuilder) => {
       builder.useHost("https://test.com")
       builder.useAutomaticDataCollectionEnabled(false)
       builder.useCredential(new BasicCredential("email", "password"))
@@ -151,8 +45,8 @@ test("SDK, middleware", async () => {
 })
 
 test("SDK, services", async () => {
-  await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
-    const app = await appSdk("test-sdk")
+  await appTest(UnitTest.DEFAULT, async () => {
+    const app = await dataIslandApp("test-sdk")
     const middlewareService = app.resolve(MiddlewareService)
     expect(middlewareService).not.toBeUndefined()
     expect(app.resolve(MiddlewareService)).toBe(middlewareService)
@@ -163,8 +57,8 @@ test("SDK, services", async () => {
 })
 
 test("SDK, middleware", async () => {
-  await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
-    const app = await appSdk("test-middleware")
+  await appTest(UnitTest.DEFAULT, async () => {
+    const app = await dataIslandApp("test-middleware")
     const middlewareService = app.resolve(MiddlewareService)
     expect(middlewareService).not.toBeUndefined()
     expect(app.resolve(MiddlewareService)).toBe(middlewareService)
@@ -199,27 +93,30 @@ test("SDK, middleware", async () => {
 })
 
 test("SDK, it is impossible to setup the same application", async () => {
-  await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
+  await appTest(UnitTest.DEFAULT, 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 = dataIslandApp(testId).then(() => {
+    })
     await expect(
-      appSdk(`test-setup-${testId}`, async () => {})
+      dataIslandApp(testId, async () => {
+      })
     ).rejects.toThrow()
     await promise
   })
 })
 
 test("SDK, setup and get this app", async () => {
-  await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
+  await appTest(UnitTest.DEFAULT, 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 = dataIslandApp(testId).then(() => {
+    })
+    await expect(dataIslandApp(testId)).resolves.toBeInstanceOf(DataIslandApp)
     await promise
   })
 })