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

package/README.md

@@ -24,7 +24,7 @@ For connecting this library to your website project simply install it using npm
 You can initialize default app sdk instance using this code example.
 
 ```
-const app = await appSdk("your-app-name", async (builder: AppBuilder) => {
+const app = await dataIslandApp("your-app-name", async (builder: AppBuilder) => {
     builder.useHost(HOST)
     builder.useCredential(new BearerCredential(TOKEN))
   })
@@ -39,7 +39,7 @@ Second required parameter for builder is Credentials. It is recomended to use Be
 You can also add requests middlewares with builder options.
 
 ```
-const app = await appSdk("your-app-name", async (builder: AppBuilder) => {
+const app = await dataIslandApp("your-app-name", async (builder: AppBuilder) => {
       builder.useHost(YOUR_HOST)
       builder.useAutomaticDataCollectionEnabled(false)
       builder.useCredential(new BasicCredential("email", "password"))
@@ -76,7 +76,7 @@ Workspaces are folder-like objects used to store files and controll access to it
 Default workspace creation example:
 
 ```
-const wsPromise = org.workspaces.create(
+const workspace = await org.workspaces.create(
       "your-workspace-name",
       "your-workspace-description",
       regulation: {

package/package.json

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

package/src/{appSdk.ts → dataIslandApp.ts}

@@ -8,7 +8,7 @@ import { UserProfile } from "./storages/userProfile"
 /**
  * DataIsland App instance.
  */
-export abstract class AppSdk {
+export abstract class DataIslandApp {
   /**
    * The name of this app.
    */

package/src/index.ts

@@ -1,12 +1,12 @@
 import { version } from "../package.json"
 import { _createApp } from "./internal/createApp.impl"
 import { type AppBuilder } from "./appBuilder"
-import { type AppSdk } from "./appSdk"
+import { type DataIslandApp } from "./dataIslandApp"
 
 export * from "./events"
 export * from "./disposable"
 export * from "./credentials"
-export * from "./appSdk"
+export * from "./dataIslandApp"
 export * from "./storages/organizations"
 export * from "./storages/organization"
 export * from "./storages/workspaces"
@@ -19,8 +19,8 @@ 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>()
+const _appsNotReady = new Map<string, Promise<DataIslandApp>>()
+const _appsReady = new Map<string, DataIslandApp>()
 
 /**
  * Current SDK version.
@@ -37,7 +37,10 @@ export const DEFAULT_NAME = "[DEFAULT]"
  */
 export const DEFAULT_HOST = "https://api.dataisland.com.ua"
 
-export function sdks(): AppSdk[] {
+/**
+ * Returns a list of DataIsland App instances.
+ */
+export function dataIslandInstances(): DataIslandApp[] {
   return Array.from(_appsReady.values())
 }
 
@@ -48,19 +51,19 @@ export function sdks(): AppSdk[] {
  * @returns A DataIsland App instance.
  * @example
  * ```js
- * import { appSdk } from 'data-island'
+ * import { dataIslandApp, DEFAULT_NAME } from '@neuralinnovations/dataisland-sdk'
  *
- * const app = await appSdk("my-app", builder => {
+ * const app = await dataIslandApp(DEFAULT_NAME, builder => {
  *  builder.useHost("https://dataisland.com.ua")
  *  builder.useAutomaticDataCollectionEnabled(true)
  *  builder.useCredential(new BasicCredential("email", "password"))
  *  })
  * ```
  */
-export async function appSdk(
+export async function dataIslandApp(
   name?: string,
   setup?: (builder: AppBuilder) => Promise<void>
-): Promise<AppSdk> {
+): Promise<DataIslandApp> {
   name = name ?? DEFAULT_NAME
 
   let appPromise = _appsNotReady.get(name)
@@ -78,7 +81,7 @@ export async function appSdk(
   } else {
     if (setup !== undefined) {
       throw new Error(
-        `App ${name} is initializing. You can't setup the same again.`
+        `DataIsland ${name} is initializing. You can't setup the same again.`
       )
     }
   }

package/src/internal/app.impl.ts

@@ -8,7 +8,7 @@ import { type Service, ServiceContext } from "../services/service"
 import { CredentialService } from "../services/credentialService"
 import { MiddlewareService } from "../services/middlewareService"
 import { type CredentialBase } from "../credentials"
-import { AppSdk } from "../appSdk"
+import { DataIslandApp } from "../dataIslandApp"
 import { RpcService } from "../services/rpcService"
 import { CommandService } from "../services/commandService"
 import {
@@ -21,7 +21,7 @@ import { Organizations } from "../storages/organizations"
 import { UserProfile } from "../storages/userProfile"
 import { isUnitTest, UnitTest } from "../unitTest"
 
-export class AppImplementation extends AppSdk {
+export class DataIslandAppImpl extends DataIslandApp {
   readonly name: string
   private _host: string = DEFAULT_HOST
   private _automaticDataCollectionEnabled: boolean = true
@@ -178,7 +178,7 @@ export class AppImplementation extends AppSdk {
 
     // log app initialized
     if (!isUnitTest(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)) {
-      console.log(`AppSDK ${this.name} initialized`)
+      console.log(`DataIsland ${this.name} initialized`)
     }
   }
 }

package/src/internal/createApp.impl.ts

@@ -1,12 +1,12 @@
-import { AppImplementation } from "./app.impl"
+import { DataIslandAppImpl } from "./app.impl"
 import { type AppBuilder } from "../appBuilder"
-import { AppSdk } from "../appSdk"
+import { DataIslandApp } from "../dataIslandApp"
 
 export async function _createApp(
   name: string,
   setup?: (builder: AppBuilder) => Promise<void>
-): Promise<AppSdk> {
-  const app = new AppImplementation(name)
+): Promise<DataIslandApp> {
+  const app = new DataIslandAppImpl(name)
   await app.initialize(setup)
   return app
 }

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/index.test.ts

@@ -1,8 +1,8 @@
 import { version } from "../package.json"
 import {
-  AppSdk,
+  DataIslandApp,
   BasicCredential,
-  appSdk,
+  dataIslandApp,
   SDK_VERSION,
   DEFAULT_NAME,
   DebugCredential
@@ -11,7 +11,7 @@ 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 { UnitTest, appTest } from "../src/unitTest"
 import { HOST, randomHash, TOKEN } from "./setup"
 
 test("SDK_VERSION", () => {
@@ -20,7 +20,7 @@ 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))
   })
@@ -28,8 +28,8 @@ test("Default SDK", async () => {
 })
 
 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"))
@@ -45,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)
@@ -57,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)
@@ -93,15 +93,15 @@ 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 = `test-setup-${randomHash()}`
-    const promise = appSdk(testId).then(() => {
+    const promise = dataIslandApp(testId).then(() => {
     })
     await expect(
-      appSdk(testId, async () => {
+      dataIslandApp(testId, async () => {
       })
     ).rejects.toThrow()
     await promise
@@ -109,14 +109,14 @@ test("SDK, it is impossible to setup the same application", async () => {
 })
 
 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 = `test-get-${randomHash()}`
-    const promise = appSdk(testId).then(() => {
+    const promise = dataIslandApp(testId).then(() => {
     })
-    await expect(appSdk(testId)).resolves.toBeInstanceOf(AppSdk)
+    await expect(dataIslandApp(testId)).resolves.toBeInstanceOf(DataIslandApp)
     await promise
   })
 })

package/test/organization.test.ts

@@ -1,4 +1,4 @@
-import { appSdk, DebugCredential } from "../src"
+import { dataIslandApp, DebugCredential } from "../src"
 import { HOST, randomHash, TOKEN } from "./setup"
 import { OrganizationImpl } from "../src/storages/organization.impl"
 
@@ -7,7 +7,7 @@ test("Organization", async () => {
   const randomName = `org-test-${randomHash()}`
 
   // create app
-  const app = await appSdk(randomName, async builder => {
+  const app = await dataIslandApp(randomName, async builder => {
     builder.useHost(HOST)
     builder.useCredential(new DebugCredential(TOKEN))
   })

package/test/services.test.ts

@@ -1,11 +1,11 @@
-import { appSdk, BasicCredential, DefaultCredential } from "../src"
+import { dataIslandApp, BasicCredential, DefaultCredential } from "../src"
 import { CredentialService } from "../src/services/credentialService"
 import { MiddlewareService } from "../src/services/middlewareService"
-import { UnitTest, AppSdkUnitTest } from "../src/unitTest"
+import { UnitTest, appTest } from "../src/unitTest"
 
 test("CredentialService", async () => {
-  await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
-    const app = await appSdk("test-services", async builder => {
+  await appTest(UnitTest.DEFAULT, async () => {
+    const app = await dataIslandApp("test-services", async builder => {
       builder.env.unitTest = UnitTest.DO_NOT_START
     })
     const credentialService = app.resolve(CredentialService)

package/test/setup.ts

@@ -1,6 +1,6 @@
-import { appSdk, AppSdk, DebugCredential } from "../src"
-import { Organization } from "../src/storages/organization"
-import { Workspace } from "../src/storages/workspace"
+import { dataIslandApp, DataIslandApp, DebugCredential } from "../src"
+import { Organization } from "../src"
+import { Workspace } from "../src"
 
 export const HOST = <string>process.env.HOST
 export const TOKEN = <string>process.env.TOKEN
@@ -10,13 +10,13 @@ export const randomHash = (length: number = 5) => {
   return `name-${((Math.random() * Math.pow(10, length)) | 0).toString(16)}`
 }
 
-export const testInOrganization = async (func: (app: AppSdk, org: Organization) => Promise<void>, config ?: {
+export const testInOrganization = async (func: (app: DataIslandApp, org: Organization) => Promise<void>, config ?: {
     host: string,
     token: string
   }
 ): Promise<void> => {
   const randomName = `org-name-${randomHash()}`
-  const app = await appSdk(randomName, async builder => {
+  const app = await dataIslandApp(randomName, async builder => {
     builder.useHost(config?.host ?? HOST)
     builder.useCredential(new DebugCredential(config?.token ?? TOKEN))
   })
@@ -35,7 +35,7 @@ export const testInOrganization = async (func: (app: AppSdk, org: Organization)
   }
 }
 
-export const testInWorkspace = async (func: (app: AppSdk, org: Organization, workspace: Workspace)
+export const testInWorkspace = async (func: (app: DataIslandApp, org: Organization, workspace: Workspace)
   => Promise<void>, config?: {
   host: string,
   token: string,

package/test/unitTest.test.ts

@@ -1,21 +1,21 @@
-import { AppSdkUnitTest, UnitTest } from "../src/unitTest"
+import { appTest, appTestCurrent, UnitTest } from "../src/unitTest"
 
 test("SDK, unitTest", async () => {
-  expect(AppSdkUnitTest.current).toBe(UnitTest.DO_NOTHING)
+  expect(appTestCurrent()).toBe(UnitTest.DO_NOTHING)
   expect(
-    await AppSdkUnitTest.test(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG, () => {
-      expect(AppSdkUnitTest.current).toBe(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)
+    await appTest(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG, () => {
+      expect(appTestCurrent()).toBe(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)
     })
   )
   expect(
-    await AppSdkUnitTest.test(
+    await appTest(
       UnitTest.DO_NOT_PRINT_INITIALIZED_LOG,
       async () => {
-        expect(AppSdkUnitTest.current).toBe(
+        expect(appTestCurrent()).toBe(
           UnitTest.DO_NOT_PRINT_INITIALIZED_LOG
         )
       }
     )
   )
-  expect(AppSdkUnitTest.current).toBe(UnitTest.DO_NOTHING)
+  expect(appTestCurrent()).toBe(UnitTest.DO_NOTHING)
 })