@neuralinnovations/dataisland-sdk 0.0.1-dev1

package/src/types.ts

@@ -0,0 +1,110 @@
+import { type Events, type Event } from './events'
+import { type Disposable } from './disposable'
+
+export interface Collection<T> {
+  get collection(): T[]
+}
+
+export type OrganizationId = string
+export type WorkspaceId = string
+export type ChatId = string
+export type FileId = string
+
+export enum OrganizationEvent {
+  ADDED,
+  REMOVED,
+  UPDATED
+}
+
+export enum FileEvent {
+  ADDED,
+  REMOVED,
+  UPDATED
+}
+
+export enum ChatEvent {
+  ADDED,
+  REMOVED,
+  UPDATED
+}
+
+export enum ChatMessageEvent {
+  ADDED,
+  REMOVED,
+  UPDATED
+}
+
+export interface File {
+  id: FileId
+  name: string
+
+  download: () => Promise<void>
+}
+
+export interface Files {
+  files: File[]
+  on: (callback: (event: Event<FileEvent, File>) => void) => Disposable
+  fetch: () => Promise<void>
+  upload: (path: string, name: string) => Promise<File>
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ChatMessage {}
+
+export interface Chat {
+  id: ChatId
+  name: string
+  on: (
+    callback: (event: Event<ChatMessageEvent, ChatMessage>) => void
+  ) => Disposable
+  messages: ChatMessage[]
+  fetch: () => Promise<void>
+  subscribe: () => void
+  unsubscribe: () => void
+}
+
+export interface Chats {
+  chats: Chat[]
+  newChat: (name: string) => Promise<Chat>
+  on: (callback: (event: Event<ChatEvent, Chat>) => void) => Disposable
+  fetch: () => Promise<void>
+}
+
+export interface Invites {
+  invite: (email: string) => Promise<void>
+  accept: (id: OrganizationId) => Promise<void>
+  decline: (id: OrganizationId) => Promise<void>
+  on: (
+    callback: (organization: Event<OrganizationEvent, Organization>) => void
+  ) => Disposable
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface Statistics {}
+
+export interface Organization {
+  name: string
+  description: string
+  id: OrganizationId
+  chats: Chats
+  files: Files
+  invites: Invites
+  statistics: Statistics
+  workspaces: Workspaces
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface Workspace {}
+
+export interface Workspaces {
+  newWorkspace: (name: string) => Promise<Workspace>
+
+  delete: (id: WorkspaceId) => Promise<void>
+}
+
+export interface Organizations
+  extends Events<OrganizationEvent, Organization>,
+    Collection<Organization> {
+  create: (name: string) => Promise<Organization>
+  delete: (id: OrganizationId) => Promise<void>
+}

package/test/disposable.test.ts

@@ -0,0 +1,39 @@
+import { DisposableContainer } from '../src'
+
+test('DisposableContainer', () => {
+  const disposable = new DisposableContainer()
+  expect(disposable.isDisposed).toBe(false)
+  expect(disposable.lifetime.isDisposed).toBe(false)
+  disposable.dispose()
+  expect(disposable.isDisposed).toBe(true)
+  expect(disposable.lifetime.isDisposed).toBe(true)
+})
+
+test('DisposableContainer, dispose order', () => {
+  const indexes: number[] = []
+  const disposable = new DisposableContainer()
+  disposable.addCallback(() => {
+    indexes.push(1)
+  })
+
+  const nested = disposable.defineNested()
+  nested.addCallback(() => {
+    indexes.push(2)
+  })
+
+  nested.lifetime.addCallback(() => {
+    indexes.push(3)
+  })
+
+  nested.lifetime.defineNested().addCallback(() => {
+    indexes.push(4)
+  })
+
+  nested.lifetime.defineNested().addCallback(() => {
+    indexes.push(5)
+  })
+
+  disposable.dispose()
+
+  expect(indexes).toEqual([5, 4, 3, 2, 1])
+})

package/test/events.test.ts

@@ -0,0 +1,151 @@
+import { EventDispatcher } from '../src'
+
+test('Events, test general', () => {
+  enum ET {
+    A,
+    B
+  }
+
+  const dispatch = new EventDispatcher<ET, number>()
+
+  let a1 = 0
+  let a2 = 0
+  let b1 = 0
+  let b2 = 0
+
+  const aDisposable1 = dispatch.subscribe((evt: { data: number }) => {
+    a1 += evt.data
+  }, ET.A)
+  const aDisposable2 = dispatch.subscribe(evt => {
+    if (evt.type === ET.A) a2 += evt.data
+  })
+  const bDisposable1 = dispatch.subscribe(evt => {
+    b1 += evt.data
+  }, ET.B)
+  const bDisposable2 = dispatch.subscribe(evt => {
+    if (evt.type === ET.B) b2 += evt.data
+  })
+
+  dispatch.dispatch({
+    type: ET.A,
+    data: 1
+  })
+
+  expect(a1).toBe(1)
+  expect(a2).toBe(1)
+  expect(b1).toBe(0)
+  expect(b2).toBe(0)
+
+  aDisposable1.dispose()
+
+  dispatch.dispatch({
+    type: ET.A,
+    data: 2
+  })
+  dispatch.dispatch({
+    type: ET.B,
+    data: 3
+  })
+
+  expect(a1).toBe(1)
+  expect(a2).toBe(3)
+  expect(b1).toBe(3)
+  expect(b2).toBe(3)
+
+  aDisposable2.dispose()
+
+  dispatch.dispatch({
+    type: ET.A,
+    data: 3
+  })
+
+  expect(a1).toBe(1)
+  expect(a2).toBe(3)
+  expect(b1).toBe(3)
+  expect(b2).toBe(3)
+
+  bDisposable1.dispose()
+  bDisposable2.dispose()
+
+  dispatch.dispatch({
+    type: ET.B,
+    data: 4
+  })
+
+  expect(a1).toBe(1)
+  expect(a2).toBe(3)
+  expect(b1).toBe(3)
+  expect(b2).toBe(3)
+})
+
+test('Events, test this', () => {
+  enum ET {
+    A,
+    B
+  }
+
+  const dispatch = new EventDispatcher<ET, number>()
+
+  const a = {
+    value: 0
+  }
+  const b = {
+    value: 0
+  }
+
+  const aDisposable = dispatch.subscribe((evt: { data: number }) => {
+    a.value += evt.data
+  }, ET.A)
+  const bDisposable = dispatch.subscribe((evt: { data: number }) => {
+    b.value += evt.data
+  }, ET.B)
+
+  dispatch.dispatch({
+    type: ET.A,
+    data: 1
+  })
+  dispatch.dispatch({
+    type: ET.B,
+    data: 2
+  })
+
+  expect(a.value).toBe(1)
+  expect(b.value).toBe(2)
+
+  aDisposable.dispose()
+  bDisposable.dispose()
+
+  dispatch.dispatch({
+    type: ET.A,
+    data: 3
+  })
+  dispatch.dispatch({
+    type: ET.B,
+    data: 4
+  })
+
+  expect(a.value).toBe(1)
+  expect(b.value).toBe(2)
+})
+
+test('Events, test unsubscribe', () => {
+  const dispatch = new EventDispatcher<unknown, number>()
+
+  let index = 0
+
+  dispatch.subscribe(evt => {
+    index += evt.data
+    evt.unsubscribe()
+  })
+  dispatch.subscribe(evt => {
+    index += evt.data
+  })
+
+  dispatch.dispatch({ data: 1 })
+
+  expect(index).toBe(2)
+
+  dispatch.dispatch({ data: 1 })
+
+  expect(index).toBe(3)
+})

package/test/index.test.ts

@@ -0,0 +1,83 @@
+import { version } from '../package.json'
+import {
+  BasicCredential,
+  appSdk,
+  SDK_VERSION,
+  DEFAULT_NAME,
+  DEFAULT_HOST
+} from '../src'
+import { MiddlewareService } from '../src/services/middlewareService'
+import { CredentialService } from '../src/services/credentialService'
+import { RpcService, RpcServiceImpl } from '../src/services/rpcService'
+import { AppBuilder } from '../src/appBuilder'
+
+test('SDK_VERSION', () => {
+  expect(SDK_VERSION).toBe(version)
+})
+
+test('Default SDK', async () => {
+  // default
+  const app = await appSdk()
+  expect(app.name).toBe(DEFAULT_NAME)
+  expect(app.host).toBe(DEFAULT_HOST)
+  expect(app.automaticDataCollectionEnabled).toBe(true)
+})
+
+test('Custom SDK settings', async () => {
+  const app = await appSdk('test', async (builder: AppBuilder) => {
+    builder.useHost('https://test.com')
+    builder.useAutomaticDataCollectionEnabled(false)
+    builder.useCredential(new BasicCredential('email', 'password'))
+    builder.addMiddleware(async (req, next) => {
+      req.headers.set('X-Test', 'test')
+      await next(req)
+    })
+  })
+  expect(app.name).toBe('test')
+  expect(app.host).toBe('https://test.com')
+  expect(app.automaticDataCollectionEnabled).toBe(false)
+})
+
+test('SDK, services', async () => {
+  const app = await appSdk('test')
+  const middlewareService = app.resolve(MiddlewareService)
+  expect(middlewareService).not.toBeUndefined()
+  expect(app.resolve(MiddlewareService)).toBe(middlewareService)
+  expect(app.resolve(CredentialService)).not.toBeUndefined()
+  expect(app.resolve(RpcService)).not.toBeUndefined()
+  expect(app.resolve(RpcService)).toBeInstanceOf(RpcServiceImpl)
+})
+
+test('SDK, middleware', async () => {
+  const app = await appSdk('test')
+  const middlewareService = app.resolve(MiddlewareService)
+  expect(middlewareService).not.toBeUndefined()
+  expect(app.resolve(MiddlewareService)).toBe(middlewareService)
+  expect(app.resolve(CredentialService)).not.toBeUndefined()
+
+  const response = await middlewareService?.process(
+    new Request('http://localhost:8080'),
+    async (req: Request): Promise<Response> => {
+      const headerXTest = req.headers.get('Custom-Test-Header')
+      expect(headerXTest).toBeNull()
+      return new Response('', { status: 200 })
+    }
+  )
+  expect(response).not.toBeUndefined()
+  expect(response?.status).toBe(200)
+
+  middlewareService?.useMiddleware(async (req, next) => {
+    req.headers.set('X-Test', 'test-value')
+    await next(req)
+  })
+
+  const response2 = await middlewareService?.process(
+    new Request('https://localhost:8080'),
+    async (req: Request): Promise<Response> => {
+      expect(req.headers.get('X-Test')).toBe('test-value')
+      return new Response('', { status: 400 })
+    }
+  )
+  expect(response2).not.toBeUndefined()
+  expect(response2?.status).toBe(400)
+})

package/test/registry.test.ts

@@ -0,0 +1,44 @@
+import { Registry } from '../src/internal/registry'
+
+class TestClass {
+  constructor(public readonly value: string) {}
+}
+
+test('Registry, test factory', () => {
+  const registry = new Registry()
+
+  const item = new TestClass('test1')
+  registry.map(TestClass).asValue(item)
+  expect(registry.get(TestClass)).toBe(item)
+
+  let index = 0
+
+  registry.map(TestClass).asFactory(() => {
+    index++
+    return new TestClass(`test_${index}`)
+  })
+
+  expect(registry.get(TestClass)).toBeInstanceOf(TestClass)
+  expect(registry.get(TestClass)).not.toBe(item)
+  expect(registry.get(TestClass)).not.toBe(registry.get(TestClass))
+
+  expect(registry.get(TestClass)?.value).toBe('test_5')
+})
+
+test('Registry, test value', () => {
+  const registry = new Registry()
+
+  const item = new TestClass('test1')
+  registry.map(TestClass).asValue(item)
+  expect(registry.get(TestClass)).toBeInstanceOf(TestClass)
+  expect(registry.get(TestClass)).toBe(item)
+})
+
+test('Registry, test singleton', () => {
+  const registry = new Registry()
+
+  registry.map(TestClass).asSingleton(() => new TestClass('test1'))
+  const singleton = registry.get(TestClass)
+  expect(singleton).toBeInstanceOf(TestClass)
+  expect(singleton).toBe(registry.get(TestClass))
+})

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "target": "ES2015",
+    "module": "amd",
+    "moduleResolution": "node",
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true,
+    "importHelpers": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "outFile": "dist/dataisland-sdk.js",
+    "rootDir": ".",
+    "allowJs": true,
+    "checkJs": true,
+    "downlevelIteration": true
+  },
+  "exclude": [
+    "dist/**/*"
+  ],
+  "include": [
+    "src/**/*"
+  ]
+}