@diory/client-js 0.1.0

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/README.md

@@ -0,0 +1,43 @@
+# Diosphere
+
+## Install
+
+```
+npm install @diory/client-js
+# or
+yarn add @diory/client-js
+```
+
+## Usage
+
+```
+const clients = [localClient, S3Client, ...]
+const { diosphere, room, diograph, diory } = DioryClient(clients)
+diosphere.initialise([connection])
+diosphere.enterRoom(room)
+diograph.focusDiory(diory)
+console.log('Hello Diosphere!', diosphere.toObject())
+```
+
+### Internal methods
+
+```
+client.getDiosphere()
+client.saveDiosphere()
+client.getDiograph()
+client.saveDiograph()
+```
+
+## Development
+
+Compile typescript in real time to `/dist` folder:
+
+```
+yarn build-watch
+```
+
+Run unit tests in the background:
+
+```
+yarn test-watch
+```

package/dist/connectionClient.d.ts

@@ -0,0 +1,14 @@
+import { IDiographObject } from '@diograph/diograph';
+import { IConnectionObject, IDiosphereObject } from '@diory/diosphere-js';
+import { IConnectionClient, IDataClient } from './types';
+declare class ConnectionClient implements IConnectionClient {
+    type: string;
+    client: IDataClient;
+    connection: IConnectionObject;
+    constructor(dataClient: IDataClient, connection: IConnectionObject);
+    getDiosphere: () => Promise<any>;
+    saveDiosphere: (diosphereObject: IDiosphereObject) => Promise<boolean>;
+    getDiograph: () => Promise<any>;
+    saveDiograph: (diographObject: IDiographObject) => Promise<boolean>;
+}
+export { ConnectionClient };

package/dist/connectionClient.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionClient = void 0;
+const path_browserify_1 = require("path-browserify");
+const DIOSPHERE_JSON = 'diosphere.json';
+const DIOGRAPH_JSON = 'diograph.json';
+class ConnectionClient {
+    constructor(dataClient, connection) {
+        this.getDiosphere = async () => {
+            const diosphereString = await this.client.readTextItem((0, path_browserify_1.join)(this.connection.address, DIOSPHERE_JSON));
+            return JSON.parse(diosphereString);
+        };
+        this.saveDiosphere = async (diosphereObject) => {
+            const diosphereString = JSON.stringify(diosphereObject);
+            return this.client.writeItem((0, path_browserify_1.join)(this.connection.address, DIOSPHERE_JSON), diosphereString);
+        };
+        this.getDiograph = async () => {
+            const diographString = await this.client.readTextItem((0, path_browserify_1.join)(this.connection.address, DIOGRAPH_JSON));
+            return JSON.parse(diographString);
+        };
+        this.saveDiograph = async (diographObject) => {
+            const diosphereString = JSON.stringify(diographObject);
+            return this.client.writeItem((0, path_browserify_1.join)(this.connection.address, DIOGRAPH_JSON), diosphereString);
+        };
+        this.type = dataClient.type;
+        this.client = dataClient;
+        this.connection = connection;
+    }
+}
+exports.ConnectionClient = ConnectionClient;

package/dist/dioryClient.d.ts

@@ -0,0 +1,20 @@
+import { IConnectionObject, IDiosphere, IRoom, IRoomObject } from '@diory/diosphere-js';
+import { IDiograph, IDiory, IDioryObject } from '@diograph/diograph';
+import { IDataClient, IDioryClient } from './types';
+declare class DioryClient implements IDioryClient {
+    dataClients: IDataClient[];
+    connections: IConnectionObject[];
+    diosphere: IDiosphere;
+    room?: IRoom;
+    diograph: IDiograph;
+    diory?: IDiory;
+    constructor(dataClients: IDataClient[]);
+    initialise: (connections: IConnectionObject[]) => Promise<void>;
+    getDiosphere: () => Promise<void>;
+    saveDiosphere: () => Promise<void>;
+    enterRoom: (roomObject: IRoomObject) => Promise<IRoom>;
+    getDiograph: () => Promise<void>;
+    saveDiograph: () => Promise<void>;
+    focusDiory: (dioryObject: IDioryObject) => IDiory;
+}
+export { DioryClient };

package/dist/dioryClient.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DioryClient = void 0;
+const diosphere_js_1 = require("@diory/diosphere-js");
+const diograph_1 = require("@diograph/diograph");
+const connectionClient_1 = require("./connectionClient");
+function getDataClient(dataClients, { client }) {
+    return dataClients.find(({ type }) => type === client);
+}
+function getConnectionClients(dataClients, connections) {
+    return connections
+        .filter(({ client }) => dataClients.some(({ type }) => type === client))
+        .map((connection) => {
+        const dataClient = getDataClient(dataClients, connection);
+        return new connectionClient_1.ConnectionClient(dataClient, connection);
+    });
+}
+class DioryClient {
+    constructor(dataClients) {
+        this.dataClients = [];
+        this.connections = [];
+        this.initialise = async (connections) => {
+            this.connections = connections;
+            await this.getDiosphere();
+            await this.enterRoom({ id: '/' });
+            await this.focusDiory({ id: '/' });
+            return;
+        };
+        this.getDiosphere = async () => {
+            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.initialise(diosphereObject);
+                }));
+            }
+            return;
+        };
+        this.saveDiosphere = async () => {
+            console.info('saveDiosphere', this.connections);
+            if (this.connections) {
+                const connectionClients = getConnectionClients(this.dataClients, this.connections);
+                await Promise.all(connectionClients.map((connectionClient) => {
+                    console.info(this.diosphere.toObject());
+                    return connectionClient.saveDiosphere(this.diosphere.toObject());
+                }));
+            }
+            return;
+        };
+        this.enterRoom = async (roomObject) => {
+            this.room = this.diosphere.getRoom(roomObject);
+            await this.getDiograph();
+            return this.room;
+        };
+        this.getDiograph = async () => {
+            var _a, _b;
+            console.info('getDiograph', (_a = this.room) === null || _a === void 0 ? void 0 : _a.connections);
+            if ((_b = this.room) === null || _b === void 0 ? void 0 : _b.connections) {
+                const connectionClients = getConnectionClients(this.dataClients, this.room.connections);
+                await Promise.all(connectionClients.map(async (connectionClient) => {
+                    const diographObject = await connectionClient.getDiograph();
+                    console.info(diographObject);
+                    return this.diograph.initialise(diographObject);
+                }));
+            }
+            return;
+        };
+        this.saveDiograph = async () => {
+            var _a, _b;
+            console.info('saveDiograph', (_a = this.room) === null || _a === void 0 ? void 0 : _a.connections);
+            if ((_b = this.room) === null || _b === void 0 ? void 0 : _b.connections) {
+                const connectionClients = getConnectionClients(this.dataClients, this.room.connections);
+                await Promise.all(connectionClients.map((connectionClient) => {
+                    console.info(this.diograph.toObject());
+                    return connectionClient.saveDiograph(this.diograph.toObject());
+                }));
+            }
+            return;
+        };
+        this.focusDiory = (dioryObject) => {
+            return (this.diory = this.diograph.getDiory(dioryObject));
+        };
+        this.dataClients = dataClients;
+        this.diosphere = new diosphere_js_1.Diosphere();
+        this.diograph = new diograph_1.Diograph();
+        this.diosphere.saveDiosphere = this.saveDiosphere;
+        this.diograph.saveDiograph = this.saveDiograph;
+    }
+}
+exports.DioryClient = DioryClient;

package/dist/dioryClient.spec.js

@@ -0,0 +1,8 @@
+"use strict";
+describe('dioryClient', () => {
+    describe('initialise()', () => {
+        it('should initialise with connections', () => {
+            expect(true).toEqual(true);
+        });
+    });
+});

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionClient = exports.DioryClient = void 0;
+var dioryClient_1 = require("./dioryClient");
+Object.defineProperty(exports, "DioryClient", { enumerable: true, get: function () { return dioryClient_1.DioryClient; } });
+var connectionClient_1 = require("./connectionClient");
+Object.defineProperty(exports, "ConnectionClient", { enumerable: true, get: function () { return connectionClient_1.ConnectionClient; } });

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { IConnectionObject, IDiosphere, IDiosphereObject, IRoom, IRoomObject } from '@diory/diosphere-js';
+import { IDiograph, IDiory } from '@diograph/diograph';
+import { IDiographObject, IDioryObject } from '@diograph/diograph';
+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[]>;
+}
+export interface IConnectionClient {
+    type: string;
+    client: IDataClient;
+    connection: IConnectionObject;
+    getDiosphere: () => Promise<IDiosphereObject>;
+    saveDiosphere: (diosphereObject: IDiosphereObject) => void;
+    getDiograph: () => Promise<IDiographObject>;
+    saveDiograph: (diographObject: IDiographObject) => void;
+}
+export interface IDioryClient {
+    dataClients: IDataClient[];
+    connections: IConnectionObject[];
+    diosphere: IDiosphere;
+    room?: IRoom;
+    diograph: IDiograph;
+    diory?: IDiory;
+    initialise: (connections: IConnectionObject[]) => Promise<void>;
+    getDiosphere: () => void;
+    saveDiosphere: () => void;
+    enterRoom: (roomObject: IRoomObject) => Promise<IRoom>;
+    getDiograph: () => void;
+    saveDiograph: () => void;
+    focusDiory: (dioryObject: IDioryObject) => IDiory;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,53 @@
+{
+  "name": "@diory/client-js",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Olli-Pekka Pohjola <op@diory.me>, Jouni Alanen <jouni@diory.me>",
+  "license": "MIT",
+  "dependencies": {
+    "@diograph/diograph": "^0.1.2",
+    "@diory/diosphere-js": "^0.2.5",
+    "path": "^0.12.7",
+    "path-browserify": "^1.0.1",
+    "uuid": "8.3.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^27.4.0",
+    "@types/path-browserify": "^1.0.2",
+    "@types/uuid": "8.3.2",
+    "jest": "^27.5.0",
+    "prettier": "^2.5.1",
+    "ts-jest": "^27.1.3",
+    "typescript": "^4.5.5"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build-watch": "yarn build --watch",
+    "prettier": "prettier --write .",
+    "test": "jest . --verbose",
+    "test-watch": "yarn test --watch",
+    "prepare": "yarn prettier && yarn test && yarn build",
+    "release-candidate": "yarn prepare && yarn version --no-git-tag-version && npm publish",
+    "release": "yarn prepare && yarn version && npm publish"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "semi": false,
+    "singleQuote": true,
+    "printWidth": 100,
+    "trailingComma": "all"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DioryMe/diosphere-js.git"
+  },
+  "keywords": [
+    "diory",
+    "diosphere"
+  ],
+  "bugs": {
+    "url": "https://github.com/DioryMe/diosphere-js/issues"
+  },
+  "homepage": "https://github.com/DioryMe/diosphere-js#readme"
+}

package/src/connectionClient.ts

@@ -0,0 +1,46 @@
+import { join } from 'path-browserify'
+
+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 diosphereString = await this.client.readTextItem(
+      join(this.connection.address, DIOSPHERE_JSON),
+    )
+    return JSON.parse(diosphereString)
+  }
+
+  saveDiosphere = async (diosphereObject: IDiosphereObject) => {
+    const diosphereString = JSON.stringify(diosphereObject)
+    return this.client.writeItem(join(this.connection.address, DIOSPHERE_JSON), diosphereString)
+  }
+
+  getDiograph = async () => {
+    const diographString = await this.client.readTextItem(
+      join(this.connection.address, DIOGRAPH_JSON),
+    )
+    return JSON.parse(diographString)
+  }
+
+  saveDiograph = async (diographObject: IDiographObject) => {
+    const diosphereString = JSON.stringify(diographObject)
+    return this.client.writeItem(join(this.connection.address, DIOGRAPH_JSON), diosphereString)
+  }
+}
+
+export { ConnectionClient }

package/src/dioryClient.spec.ts

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

package/src/dioryClient.ts

@@ -0,0 +1,133 @@
+import { Diosphere, IConnectionObject, IDiosphere, IRoom, IRoomObject } from '@diory/diosphere-js'
+import { Diograph, IDiograph, IDiory, IDioryObject } from '@diograph/diograph'
+
+import { IConnectionClient, IDataClient, IDioryClient } from './types'
+import { ConnectionClient } from './connectionClient'
+
+function getDataClient(
+  dataClients: IDataClient[],
+  { client }: IConnectionObject,
+): IDataClient | undefined {
+  return dataClients.find(({ type }) => type === client)
+}
+
+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[]
+}
+
+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<void> => {
+    this.connections = connections
+
+    await this.getDiosphere()
+    await this.enterRoom({ id: '/' })
+    await this.focusDiory({ id: '/' })
+
+    return
+  }
+
+  getDiosphere = async (): Promise<void> => {
+    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.initialise(diosphereObject)
+        }),
+      )
+    }
+
+    return
+  }
+
+  saveDiosphere = async (): Promise<void> => {
+    console.info('saveDiosphere', this.connections)
+    if (this.connections) {
+      const connectionClients = getConnectionClients(this.dataClients, this.connections)
+
+      await Promise.all(
+        connectionClients.map((connectionClient) => {
+          console.info(this.diosphere.toObject())
+          return connectionClient.saveDiosphere(this.diosphere.toObject())
+        }),
+      )
+    }
+
+    return
+  }
+
+  enterRoom = async (roomObject: IRoomObject): Promise<IRoom> => {
+    this.room = this.diosphere.getRoom(roomObject)
+
+    await this.getDiograph()
+
+    return this.room
+  }
+
+  getDiograph = async (): Promise<void> => {
+    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)
+          return this.diograph.initialise(diographObject)
+        }),
+      )
+    }
+
+    return
+  }
+
+  saveDiograph = async (): Promise<void> => {
+    console.info('saveDiograph', this.room?.connections)
+    if (this.room?.connections) {
+      const connectionClients = getConnectionClients(this.dataClients, this.room.connections)
+
+      await Promise.all(
+        connectionClients.map((connectionClient) => {
+          console.info(this.diograph.toObject())
+          return connectionClient.saveDiograph(this.diograph.toObject())
+        }),
+      )
+    }
+
+    return
+  }
+
+  focusDiory = (dioryObject: IDioryObject): IDiory => {
+    return (this.diory = this.diograph.getDiory(dioryObject))
+  }
+}
+
+export { DioryClient }

package/src/index.ts

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

package/src/types.ts

@@ -0,0 +1,48 @@
+import {
+  IConnectionObject,
+  IDiosphere,
+  IDiosphereObject,
+  IRoom,
+  IRoomObject,
+} from '@diory/diosphere-js'
+import { IDiograph, IDiory } from '@diograph/diograph'
+import { IDiographObject, IDioryObject } from '@diograph/diograph'
+
+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[]>
+}
+
+export interface IConnectionClient {
+  type: string
+  client: IDataClient
+  connection: IConnectionObject
+  getDiosphere: () => Promise<IDiosphereObject>
+  saveDiosphere: (diosphereObject: IDiosphereObject) => void
+  getDiograph: () => Promise<IDiographObject>
+  saveDiograph: (diographObject: IDiographObject) => void
+}
+
+export interface IDioryClient {
+  dataClients: IDataClient[]
+  connections: IConnectionObject[]
+  diosphere: IDiosphere
+  room?: IRoom
+  diograph: IDiograph
+  diory?: IDiory
+  initialise: (connections: IConnectionObject[]) => Promise<void>
+  getDiosphere: () => void
+  saveDiosphere: () => void
+  enterRoom: (roomObject: IRoomObject) => Promise<IRoom>
+  getDiograph: () => void
+  saveDiograph: () => void
+  focusDiory: (dioryObject: IDioryObject) => IDiory
+}

package/tsconfig.json

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