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

package/README.md

@@ -4,7 +4,7 @@ The DataIsland Client SDK is a TypeScript library designed to seamlessly integra
 
 ## Table of contents
 
-1. [Connect](#connect)
+1. [Install](#install)
 2. [Create app](#create-app)
 3. [Use organizations](#use-organizations)
 4. [Use chat](#use-chat)
@@ -13,41 +13,49 @@ The DataIsland Client SDK is a TypeScript library designed to seamlessly integra
 7. [Use access groups](#use-access-groups)
 8. [Use invites](#use-invites)
 
-### Connect
+### Install
 
 For connecting this library to your website project simply install it using npm package manager.
 
-`npm i @neuralinnovations/dataisland-sdk`
+```shell
+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))
-  })
+```typescript
+// default production app sdk instance
+const dataIslandSdk = await dataIslandApp()
+
+// specific app sdk instance 
+// use this if you have more than one app 
+// or using custom api server
+const yourAppNameSdk = await dataIslandApp('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.
+_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.
+Second required parameter for builder is Credentials. It is recomended to use Bearer credentials instance and pass your user **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)
-      })
-    })
+```typescript
+const app = await dataIslandApp('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
@@ -61,12 +69,12 @@ By default all user organizations are fetched with user profile during app sdk s
 
 Default organization creation code example:
 
-```
+```typescript
 // create organization
-  const org = await app.organizations.create(
-    "your-organization-name",
-    "your-organization-description"
-  )
+const org = await app.organizations.create(
+  'your-organization-name',
+  'your-organization-description'
+)
 ```
 
 ### Use workspaces
@@ -75,16 +83,26 @@ Workspaces are folder-like objects used to store files and controll access to it
 
 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"
-      }
-    )
+```typescript
+// create workspace
+// isCreateNewGroup: boolean - "Bool option for new group creation"
+// newGroupName: string - "New group name"
+// groupIds: string[] - "Array of selected accessed groups IDs"
+const workspace = await org.workspaces.create(
+  // name of new workspace
+  'your-workspace-name',
+  // description of new workspace
+  'your-workspace-description',
+  // regulation options
+  {
+    // create new group for this workspace
+    isCreateNewGroup: true,
+    // new group name
+    newGroupName: 'your-new-group-name',
+    // array of selected groups IDs
+    groupIds: []
+  }
+)
 ```
 
 ### Use files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralinnovations/dataisland-sdk",
-  "version": "0.0.1-dev4",
+  "version": "0.0.1-dev6",
   "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)
 })