@diory/client-js 0.2.0-rc2 → 0.2.0-rc4

package/.github/workflows/publish.yml

@@ -0,0 +1,44 @@
+name: Publish to NPM
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Specify the version to publish'
+        required: true
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: yarn install
+
+      - name: Build
+        run: yarn build
+
+      - name: Update version using Yarn
+        run: |
+          git config user.email "<>"
+          git config user.name "GitHub Actions Bot"
+          yarn version --new-version ${{ github.event.inputs.version }}
+
+      - name: Push version update commit
+        run: git push origin HEAD --follow-tags
+
+      - name: Publish to NPM
+        run: npm publish --access=public --tag=next
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}

package/.github/workflows/yarn-test.yml

@@ -0,0 +1,23 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Test (yarn test)
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      CI: false
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+      - run: yarn
+      - run: yarn build
+      - run: yarn test

package/.nvmrc

@@ -0,0 +1 @@
+20.10.0

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testPathIgnorePatterns: ['dist', 'node_modules'],
+}

package/package.json

@@ -1,11 +1,8 @@
 {
   "name": "@diory/client-js",
-  "version": "0.2.0-rc2",
+  "version": "0.2.0-rc4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "author": "Olli-Pekka Pohjola <op@diory.me>, Jouni Alanen <jouni@diory.me>",
   "license": "MIT",
   "dependencies": {

package/src/connectionClient/connectionClient.spec.ts

@@ -0,0 +1,19 @@
+describe('connectionClient', () => {
+  describe('construct()', () => {
+    it('should construct with dataClient and connection', () => {
+      expect(true).toEqual(true)
+    })
+  })
+
+  describe('getDiosphere()', () => {
+    it('should get diosphere', () => {
+      expect(true).toEqual(true)
+    })
+  })
+
+  describe('saveDiosphere()', () => {
+    it('should save diosphere object', () => {
+      expect(true).toEqual(true)
+    })
+  })
+})

package/src/connectionClient/connectionClient.ts

@@ -0,0 +1,52 @@
+import { join } from 'path-browserify'
+import { generateDiograph } from '@diograph/folder-generator'
+
+import { IDiographObject } from '@diograph/diograph'
+import { IConnectionObject, IDiosphereObject } from '@diory/diosphere-js'
+import { IConnectionClient, IDataClient } from '../types'
+
+const DIOSPHERE_JSON = 'diosphere.json'
+const DIOGRAPH_JSON = 'diograph.json'
+
+class ConnectionClient implements IConnectionClient {
+  type: string
+  client: IDataClient
+  connection: IConnectionObject
+
+  constructor(dataClient: IDataClient, connection: IConnectionObject) {
+    this.type = dataClient.type
+    this.client = dataClient
+    this.connection = connection
+  }
+
+  getDiosphere = async () => {
+    const path = join(this.connection.address, DIOSPHERE_JSON)
+    const diosphereString = await this.client.readTextItem(path)
+    return JSON.parse(diosphereString)
+  }
+
+  saveDiosphere = async (diosphereObject: IDiosphereObject) => {
+    const path = join(this.connection.address, DIOSPHERE_JSON)
+    const diosphereString = JSON.stringify(diosphereObject, null, 2)
+    return this.client.writeItem(path, diosphereString)
+  }
+
+  getDiograph = async () => {
+    const path = join(this.connection.address, DIOGRAPH_JSON)
+    const diographString = await this.client.readTextItem(path)
+    return JSON.parse(diographString)
+  }
+
+  saveDiograph = async (diographObject: IDiographObject) => {
+    const path = join(this.connection.address, DIOGRAPH_JSON)
+    const diographString = JSON.stringify(diographObject, null, 2)
+    return this.client.writeItem(path, diographString)
+  }
+
+  generateDiograph = async (): Promise<IDiographObject> => {
+    const { diograph } = await generateDiograph(this.connection.address, this.client)
+    return diograph.toObject()
+  }
+}
+
+export { ConnectionClient }

package/src/dioryClient/dioryClient.spec.ts

@@ -0,0 +1,19 @@
+describe('dioryClient', () => {
+  describe('constructor()', () => {
+    it('should construct with dataClient', () => {
+      expect(true).toEqual(true)
+    })
+  })
+
+  describe('initialise()', () => {
+    it('should initialise with connections', () => {
+      expect(true).toEqual(true)
+    })
+  })
+
+  describe('enterRoom()', () => {
+    it('should initialise with connections', () => {
+      expect(true).toEqual(true)
+    })
+  })
+})

package/src/dioryClient/dioryClient.ts

@@ -0,0 +1,141 @@
+import { Diosphere, IConnectionObject, IDiosphere, IRoom, IRoomObject } from '@diory/diosphere-js'
+import { Diograph, IDiograph, IDiory, IDioryObject } from '@diograph/diograph'
+
+import { IDioryClient, IDataClient } from '../types'
+import { getConnectionClients } from '../utils/getConnectionClients'
+
+class DioryClient implements IDioryClient {
+  dataClients: IDataClient[] = []
+  connections: IConnectionObject[] = []
+  diosphere: IDiosphere
+  room?: IRoom
+  diograph: IDiograph
+  diory?: IDiory
+
+  constructor(dataClients: IDataClient[]) {
+    this.dataClients = dataClients
+
+    this.diosphere = new Diosphere()
+    this.diograph = new Diograph()
+
+    this.diosphere.saveDiosphere = this.saveDiosphere
+    this.diograph.saveDiograph = this.saveDiograph
+  }
+
+  initialise = async (connections: IConnectionObject[]): Promise<IDioryClient> => {
+    this.connections = connections
+
+    this.diosphere.resetRooms()
+    await this.getDiosphere()
+    await this.enterRoom({ id: '/' })
+
+    return this
+  }
+
+  enterRoom = async (roomObject: IRoomObject): Promise<IRoom> => {
+    this.room = this.diosphere.getRoom(roomObject)
+
+    this.diograph.resetDiograph()
+    await this.getDiograph()
+    this.focusDiory({ id: '/' })
+
+    await this.generateDiograph()
+
+    return this.room
+  }
+
+  focusDiory = (dioryObject: IDioryObject): IDiory => {
+    return (this.diory = this.diograph.getDiory(dioryObject))
+  }
+
+  getDiosphere = async (): Promise<IDiosphere> => {
+    console.info('getDiosphere', this.connections)
+    if (this.connections) {
+      const connectionClients = getConnectionClients(this.dataClients, this.connections)
+
+      await Promise.all(
+        connectionClients.map(async (connectionClient) => {
+          const diosphereObject = await connectionClient.getDiosphere()
+          console.info(diosphereObject)
+          return this.diosphere.addDiosphere(diosphereObject)
+        }),
+      )
+    }
+
+    return this.diosphere
+  }
+
+  saveDiosphere = async (): Promise<IDiosphere> => {
+    console.info('saveDiosphere', this.connections)
+    if (this.connections) {
+      const connectionClients = getConnectionClients(this.dataClients, this.connections)
+
+      await Promise.all(
+        connectionClients.map(async (connectionClient) => {
+          console.info(this.diosphere.toObject())
+          await connectionClient.saveDiosphere(this.diosphere.toObject())
+          return
+        }),
+      )
+    }
+
+    return this.diosphere
+  }
+
+  getDiograph = async (): Promise<IDiograph> => {
+    console.info('getDiograph', this.room?.connections)
+    if (this.room?.connections) {
+      const connectionClients = getConnectionClients(this.dataClients, this.room.connections)
+
+      await Promise.all(
+        connectionClients.map(async (connectionClient) => {
+          const diographObject = await connectionClient.getDiograph()
+          console.info(diographObject)
+          this.diograph.addDiograph(diographObject)
+          return
+        }),
+      )
+    }
+
+    return this.diograph
+  }
+
+  saveDiograph = async (): Promise<IDiograph> => {
+    console.info('saveDiograph', this.room?.connections)
+    if (this.room?.connections) {
+      const connectionClients = getConnectionClients(this.dataClients, this.room.connections)
+
+      await Promise.all(
+        connectionClients.map(async (connectionClient) => {
+          console.info(this.diograph.toObject())
+          await connectionClient.saveDiograph(this.diograph.toObject())
+          return
+        }),
+      )
+    }
+
+    return this.diograph
+  }
+
+  generateDiograph = async (): Promise<IDiograph> => {
+    console.info('generateDiograph', this.room?.connections)
+    if (this.room?.connections) {
+      const connectionClients = getConnectionClients(this.dataClients, this.room?.connections)
+
+      await Promise.all(
+        connectionClients.map(async (connectionClient) => {
+          const diographObject = await connectionClient.generateDiograph()
+          console.info(diographObject)
+          this.diograph.addDiograph(diographObject)
+
+          await connectionClient.saveDiograph(this.diograph.toObject())
+          return
+        }),
+      )
+    }
+
+    return this.diograph
+  }
+}
+
+export { DioryClient }

package/src/index.ts

@@ -0,0 +1,3 @@
+export { DioryClient } from './dioryClient/dioryClient'
+export { ConnectionClient } from './connectionClient/connectionClient'
+export { IDioryClient, IConnectionClient, IDataClient, IFileType, IMetadata } from './types'

package/src/types.ts

@@ -0,0 +1,64 @@
+import {
+  IConnectionObject,
+  IDiosphere,
+  IDiosphereObject,
+  IRoom,
+  IRoomObject,
+} from '@diory/diosphere-js'
+import { IDiograph, IDiographObject, IDiory, IDioryObject } from '@diograph/diograph'
+
+export interface IMetadata {
+  name: string
+  created?: string
+  modified?: string
+}
+
+export interface IFileType {
+  ext?: string
+  mime?: string
+}
+
+export interface IDataClient {
+  type: string
+  readTextItem(url: string): Promise<string>
+  readItem(url: string): Promise<Buffer>
+  readToStream(url: string): any
+  exists(url: string): Promise<boolean>
+  writeTextItem(url: string, fileContent: string): Promise<boolean>
+  writeItem(url: string, fileContent: Buffer | string): Promise<boolean>
+  deleteItem(url: string): Promise<boolean>
+  deleteFolder(url: string): Promise<void>
+  list(url: string): Promise<string[]>
+  getFileNames(url: string): Promise<string[]>
+  getFolderNames(url: string): Promise<string[]>
+  getMetadata(url: string): IMetadata
+  getFileType(url: string): Promise<IFileType>
+}
+
+export interface IConnectionClient {
+  type: string
+  client: IDataClient
+  connection: IConnectionObject
+  getDiosphere: () => Promise<IDiosphereObject>
+  saveDiosphere: (diosphereObject: IDiosphereObject) => void
+  getDiograph: () => Promise<IDiographObject>
+  saveDiograph: (diographObject: IDiographObject) => void
+  generateDiograph: () => Promise<IDiographObject>
+}
+
+export interface IDioryClient {
+  dataClients: IDataClient[]
+  connections: IConnectionObject[]
+  diosphere: IDiosphere
+  room?: IRoom
+  diograph: IDiograph
+  diory?: IDiory
+  initialise: (connections: IConnectionObject[]) => Promise<IDioryClient>
+  enterRoom: (roomObject: IRoomObject) => Promise<IRoom>
+  focusDiory: (dioryObject: IDioryObject) => IDiory
+  getDiosphere: () => Promise<IDiosphere>
+  saveDiosphere: () => Promise<IDiosphere>
+  getDiograph: () => Promise<IDiograph>
+  saveDiograph: () => Promise<IDiograph>
+  generateDiograph: () => Promise<IDiograph>
+}

package/src/utils/getConnectionClients.ts

@@ -0,0 +1,23 @@
+import { IConnectionObject } from '@diory/diosphere-js'
+
+import { ConnectionClient } from '../connectionClient/connectionClient'
+import { IConnectionClient, IDataClient } from '../types'
+
+function getDataClient(
+  dataClients: IDataClient[],
+  { client }: IConnectionObject,
+): IDataClient | undefined {
+  return dataClients.find(({ type }) => type === client)
+}
+
+export function getConnectionClients(
+  dataClients: IDataClient[],
+  connections: IConnectionObject[],
+): IConnectionClient[] {
+  return connections
+    .filter(({ client }) => dataClients.some(({ type }) => type === client))
+    .map((connection) => {
+      const dataClient = getDataClient(dataClients, connection)
+      return new ConnectionClient(dataClient!, connection)
+    }) as IConnectionClient[]
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "declaration": true,
+    "target": "es2017",
+    "module": "commonjs",
+    "strict": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "exclude": ["node_modules", "dist"]
+}