@dxos/client-services 0.1.0

package/src/packlets/services/testing/spaces.test.ts

@@ -0,0 +1,87 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { MemorySignalManagerContext } from '@dxos/messaging';
+import { ObjectModel } from '@dxos/object-model';
+import { afterTest } from '@dxos/testutils';
+
+import { createServiceContext } from './testing';
+
+describe('services/spaces', function () {
+  it('space genesis', async function () {
+    const peer = await createServiceContext();
+    await peer.open();
+    afterTest(() => peer.close());
+
+    await peer.createIdentity();
+
+    const space = await peer.spaceManager!.createSpace();
+    expect(space.database).not.to.be.undefined;
+    expect(peer.spaceManager!.spaces.has(space.key)).to.be.true;
+    await space.close();
+  });
+
+  it('space genesis with database', async function () {
+    const peer = await createServiceContext();
+    await peer.open();
+    afterTest(() => peer.close());
+
+    await peer.createIdentity();
+    const space = await peer.spaceManager!.createSpace();
+
+    {
+      const item = await space.database!.createItem<ObjectModel>({ type: 'test' });
+      void item.model.set('name', 'test');
+    }
+
+    {
+      const [item] = space.database!.select({ type: 'test' }).exec().entities;
+      expect(item.model.get('name')).to.eq('test');
+    }
+
+    await space.close();
+  });
+
+  it('create and accepts space invitations', async function () {
+    const signalContext = new MemorySignalManagerContext();
+
+    const peer1 = await createServiceContext({ signalContext });
+    const peer2 = await createServiceContext({ signalContext });
+
+    await peer1.open();
+    await peer2.open();
+    afterTest(() => peer1.close());
+    afterTest(() => peer2.close());
+
+    await peer1.createIdentity();
+    await peer2.createIdentity();
+
+    const space1 = await peer1.spaceManager!.createSpace();
+    const invitation = await peer1.createInvitation(space1.key);
+
+    const space2 = await peer2.acceptInvitation(invitation);
+    expect(space1.key).to.deep.eq(space2.key);
+
+    // TODO(burdon): Write multiple items.
+
+    {
+      // Check item replicated from 1 => 2.
+      const item1 = await space1.database!.createItem({ type: 'dxos.example.1' });
+      const item2 = await space2.database!.waitForItem({ type: 'dxos.example.1' });
+      expect(item1.id).to.eq(item2.id);
+    }
+
+    {
+      // Check item replicated from 2 => 1.
+      const item1 = await space2.database!.createItem({ type: 'dxos.example.2' });
+      const item2 = await space1.database!.waitForItem({ type: 'dxos.example.2' });
+      expect(item1.id).to.eq(item2.id);
+    }
+
+    await space1.close();
+    await space2.close();
+  });
+});

package/src/packlets/services/testing/testing.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
+import { ModelFactory } from '@dxos/model-factory';
+import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { ObjectModel } from '@dxos/object-model';
+import { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
+
+import { ServiceContext } from '../service-context';
+
+// TODO(burdon): Create test builder.
+export const createServiceContext = async ({
+  signalContext = new MemorySignalManagerContext(),
+  storage = createStorage({ type: StorageType.RAM })
+}: {
+  signalContext?: MemorySignalManagerContext;
+  storage?: Storage;
+} = {}) => {
+  const networkManager = new NetworkManager({
+    signalManager: new MemorySignalManager(signalContext),
+    transportFactory: MemoryTransportFactory
+  });
+
+  const modelFactory = new ModelFactory().registerModel(ObjectModel);
+  return new ServiceContext(storage, networkManager, modelFactory);
+};

package/src/packlets/storage/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './storage';

package/src/packlets/storage/storage.ts

@@ -0,0 +1,97 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import jsondown from 'jsondown';
+import leveljs from 'level-js';
+import memdown from 'memdown';
+
+import { Runtime } from '@dxos/protocols/proto/dxos/config';
+import { createStorage, StorageType } from '@dxos/random-access-storage';
+import { isNode } from '@dxos/util';
+
+import StorageDriver = Runtime.Client.Storage.StorageDriver;
+import { InvalidConfigurationError } from '../../errors';
+
+export type KeyStorageType = 'ram' | 'leveljs' | 'jsondown';
+
+// TODO(burdon): Factor out.
+export const createStorageObjects = (config: Runtime.Client.Storage) => {
+  const {
+    path = 'dxos/storage', // TODO(burdon): Factor out const.
+    storageType,
+    keyStorage,
+    persistent = false
+  } = config ?? {};
+
+  if (persistent && storageType === StorageDriver.RAM) {
+    throw new InvalidConfigurationError('RAM storage cannot be used in persistent mode.');
+  }
+  if (!persistent && storageType !== undefined && storageType !== StorageDriver.RAM) {
+    throw new InvalidConfigurationError('Cannot use a persistent storage in not persistent mode.');
+  }
+  if (persistent && keyStorage === StorageDriver.RAM) {
+    throw new InvalidConfigurationError('RAM key storage cannot be used in persistent mode.');
+  }
+  if (!persistent && keyStorage !== StorageDriver.RAM && keyStorage !== undefined) {
+    throw new InvalidConfigurationError('Cannot use a persistent key storage in not persistent mode.');
+  }
+
+  return {
+    storage: createStorage({
+      type: persistent ? toStorageType(storageType) : StorageType.RAM,
+      root: `${path}/`
+    }),
+    keyStorage: createKeyStorage(`${path}/keystore`, persistent ? toKeyStorageType(keyStorage) : 'ram')
+  };
+};
+
+// TODO(burdon): Factor out.
+const createKeyStorage = (path: string, type?: KeyStorageType) => {
+  const defaultedType = type ?? (isNode() ? 'jsondown' : 'leveljs');
+
+  switch (defaultedType) {
+    case 'leveljs':
+      return leveljs(path);
+    case 'jsondown':
+      return jsondown(path);
+    case 'ram':
+      return memdown();
+    default:
+      throw new InvalidConfigurationError(`Invalid key storage type: ${defaultedType}`);
+  }
+};
+
+const toStorageType = (type: StorageDriver | undefined): StorageType | undefined => {
+  switch (type) {
+    case undefined:
+      return undefined;
+    case StorageDriver.RAM:
+      return StorageType.RAM;
+    case StorageDriver.CHROME:
+      return StorageType.CHROME;
+    case StorageDriver.FIREFOX:
+      return StorageType.FIREFOX;
+    case StorageDriver.IDB:
+      return StorageType.IDB;
+    case StorageDriver.NODE:
+      return StorageType.NODE;
+    default:
+      throw new Error(`Invalid storage type: ${StorageDriver[type]}`);
+  }
+};
+
+const toKeyStorageType = (type: StorageDriver | undefined): KeyStorageType | undefined => {
+  switch (type) {
+    case undefined:
+      return undefined;
+    case StorageDriver.RAM:
+      return 'ram';
+    case StorageDriver.LEVELJS:
+      return 'leveljs';
+    case StorageDriver.JSONDOWN:
+      return 'jsondown';
+    default:
+      throw new Error(`Invalid key storage type: ${StorageDriver[type]}`);
+  }
+};

package/src/typings.d.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+declare module 'jsondown';