@dxos/client-services 0.1.1 → 0.1.3

package/src/packlets/services/impl/party.ts

@@ -1,305 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import assert from 'node:assert';
-import { v4 } from 'uuid';
-
-import { latch } from '@dxos/async';
-import { Stream } from '@dxos/codec-protobuf';
-import { todo } from '@dxos/debug';
-import {
-  AuthenticateInvitationRequest,
-  CreateInvitationRequest,
-  CreateSnapshotRequest,
-  GetPartyDetailsRequest,
-  InvitationRequest,
-  InvitationState,
-  Party,
-  PartyDetails,
-  PartyService as PartyServiceRpc,
-  RedeemedInvitation,
-  SetPartyStateRequest,
-  SubscribeMembersRequest,
-  SubscribeMembersResponse,
-  SubscribePartiesResponse,
-  SubscribePartyRequest,
-  SubscribePartyResponse
-} from '@dxos/protocols/proto/dxos/client';
-import { PartySnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
-import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
-
-import { InvitationWrapper, InviteeInvitation, InviteeInvitations } from '../../invitations';
-import { ServiceContext } from '../service-context';
-
-/**
- * Party service implementation.
- */
-// TODO(burdon): Rename Space.
-export class PartyService implements PartyServiceRpc {
-  private inviteeInvitations: InviteeInvitations = new Map();
-
-  constructor(private readonly serviceContext: ServiceContext) {}
-
-  subscribeToParty(request: SubscribePartyRequest): Stream<SubscribePartyResponse> {
-    return new Stream(({ next }) => {
-      next({
-        party: {
-          publicKey: request.partyKey,
-          isOpen: true,
-          isActive: true,
-          members: []
-        }
-      });
-    });
-    // const update = (next: (message: SubscribePartyResponse) => void) => {
-    //   try {
-    //     const party = this.echo.getParty(request.party_key);
-    //     next({
-    //       party: party && {
-    //         public_key: party.key,
-    //         is_open: party.is_open,
-    //         is_active: party.is_active,
-    //         members: party.queryMembers().value
-    //       }
-    //     });
-    //   } catch (err) {
-    //     if (err instanceof InvalidStateError) {
-    //       // Do nothing.
-    //     } else {
-    //       throw err;
-    //     }
-    //   }
-    // };
-
-    // const party = this.serviceContext.brane.getParty(request.party_key);
-    // if (party) {
-    //   return new Stream(({ next }) => party.update.on(() => update(next)));
-    // } else {
-    //   return new Stream(({ next }) => {
-    //     let unsubscribeParty: () => void;
-    //     const unsubscribeParties = this.echo.queryParties().subscribe((parties) => {
-    //       const party = parties.find((party) => party.key.equals(request.party_key));
-    //       if (party && !unsubscribeParty) {
-    //         unsubscribeParty = party.update.on(() => update(next));
-    //       }
-    //     });
-
-    //     update(next);
-
-    //     return () => {
-    //       unsubscribeParties();
-    //       unsubscribeParty?.();
-    //     };
-    //   });
-    // }
-  }
-
-  subscribeParties() {
-    return new Stream<SubscribePartiesResponse>(({ next }) => {
-      const update = () => {
-        next({
-          parties: Array.from(this.serviceContext.spaceManager!.spaces.values()).map((space) => ({
-            publicKey: space.key,
-            isOpen: true,
-            isActive: true
-          }))
-        });
-      };
-
-      setTimeout(async () => {
-        if (!this.serviceContext.spaceManager) {
-          next({ parties: [] });
-        }
-
-        await this.serviceContext.initialized.wait();
-
-        update();
-        return this.serviceContext.spaceManager!.update.on(update);
-      });
-    });
-  }
-
-  async getPartyDetails(request: GetPartyDetailsRequest): Promise<PartyDetails> {
-    return todo();
-    // const party = this.echo.getParty(request.party_key) ?? raise(new SpaceNotFoundError(request.party_key));
-    // return {
-    //   processedTimeframe: party.timeframe
-    // };
-  }
-
-  async createParty(): Promise<Party> {
-    await this.serviceContext.initialized.wait();
-    const space = await this.serviceContext.spaceManager!.createSpace();
-    return {
-      publicKey: space.key,
-      isOpen: true,
-      isActive: true
-    };
-  }
-
-  async cloneParty(snapshot: PartySnapshot): Promise<Party> {
-    return todo();
-    // const party = await this.echo.cloneParty(snapshot);
-    // return {
-    //   public_key: party.key,
-    //   is_open: party.is_open,
-    //   is_active: party.is_active
-    // };
-  }
-
-  async setPartyState(request: SetPartyStateRequest) {
-    return todo();
-    // const party = this.echo.getParty(request.party_key);
-    // if (!party) {
-    //   throw new Error('Party not found');
-    // }
-
-    // if (request.open === true) {
-    //   await party.open();
-    // } else if (request.open === false) {
-    //   await party.close();
-    // } // Undefined preserves previous state.
-
-    // if (request.active_global === true) {
-    //   await party.activate({ global: true });
-    // } else if (request.active_global === false) {
-    //   await party.deactivate({ global: true });
-    // } // Undefined preserves previous state.
-
-    // if (request.active_device === true) {
-    //   await party.activate({ device: true });
-    // } else if (request.active_device === false) {
-    //   await party.deactivate({ device: true });
-    // } // Undefined preserves previous state.
-    // return {
-    //   public_key: party.key,
-    //   is_open: party.is_open,
-    //   is_active: party.is_active
-    // };
-  }
-
-  createInvitation(request: CreateInvitationRequest): Stream<InvitationRequest> {
-    return new Stream(({ next, close }) => {
-      setTimeout(async () => {
-        try {
-          let invitation: InvitationWrapper;
-          if (!request.inviteeKey) {
-            // const secret = Buffer.from(generatePasscode());
-            // const secretProvider = async () => {
-            //   next({ state: InvitationState.CONNECTED });
-            //   return Buffer.from(secret);
-            // };
-            invitation = await this.serviceContext.createInvitation(request.partyKey, () => {
-              next({ state: InvitationState.SUCCESS });
-              close();
-            });
-
-            assert(invitation.type === InvitationDescriptor.Type.INTERACTIVE);
-            // invitation.secret = Buffer.from(secret);
-          } else {
-            todo();
-            // invitation = await party.invitationManager.createOfflineInvitation(request.invitee_key);
-          }
-
-          // TODO(burdon): Change stream type.
-          next({
-            state: InvitationState.WAITING_FOR_CONNECTION,
-            descriptor: invitation!.toProto()
-          });
-
-          // if (invitation.type === InvitationDescriptor.Type.OFFLINE) {
-          //   close();
-          // }
-        } catch (err: any) {
-          next({ state: InvitationState.ERROR, error: err.message });
-          close();
-        }
-      });
-    });
-  }
-
-  acceptInvitation(request: InvitationDescriptor): Stream<RedeemedInvitation> {
-    return new Stream(({ next, close }) => {
-      const id = v4();
-      const [, secretTrigger] = latch();
-      const inviteeInvitation: InviteeInvitation = { secretTrigger };
-
-      // Secret will be provided separately (in AuthenticateInvitation).
-      // Process will continue when `secretLatch` resolves, triggered by `secretTrigger`.
-      // const secretProvider: SecretProvider = async () => {
-      //   await secretLatch;
-      //   const secret = inviteeInvitation.secret;
-      //   if (!secret) {
-      //     throw new Error('Secret not provided.');
-      //   }
-
-      //   return Buffer.from(secret);
-      // };
-
-      // Joining process is kicked off, and will await authentication with a secret.
-      const partyPromise = this.serviceContext.acceptInvitation(InvitationWrapper.fromProto(request));
-      this.inviteeInvitations.set(id, inviteeInvitation);
-      next({ id, state: InvitationState.CONNECTED });
-
-      partyPromise
-        .then((party) => {
-          next({ id, state: InvitationState.SUCCESS, partyKey: party.key });
-        })
-        .catch((err) => {
-          console.error(err);
-          next({ id, state: InvitationState.ERROR, error: String(err) });
-        })
-        .finally(() => {
-          close();
-        });
-    });
-  }
-
-  async authenticateInvitation(request: AuthenticateInvitationRequest) {
-    assert(request.processId, 'Process ID is missing.');
-    const invitation = this.inviteeInvitations.get(request.processId);
-    assert(invitation, 'Invitation not found.');
-    assert(request.secret, 'Secret not provided.');
-
-    // Supply the secret, and move the internal invitation process by triggering the secretTrigger.
-    invitation.secret = request.secret;
-    invitation.secretTrigger?.();
-  }
-
-  subscribeMembers(request: SubscribeMembersRequest): Stream<SubscribeMembersResponse> {
-    return new Stream(({ next }) => {
-      next({
-        members: []
-      });
-    });
-    // const party = this.echo.getParty(request.party_key);
-    // if (party) {
-    //   return resultSetToStream(party.queryMembers(), (members): SubscribeMembersResponse => ({ members }));
-    // } else {
-    //   return new Stream(({ next }) => {
-    //     let unsubscribeMembers: () => void;
-    //     const unsubscribeParties = this.echo.queryParties().subscribe((parties) => {
-    //       const party = parties.find((party) => party.key.equals(request.party_key));
-    //       if (!unsubscribeMembers && party) {
-    //         const resultSet = party.queryMembers();
-    //         next({ members: resultSet.value });
-    //         unsubscribeMembers = resultSet.update.on(() => next({ members: resultSet.value }));
-    //       }
-    //     });
-
-    //     return () => {
-    //       unsubscribeParties();
-    //       unsubscribeMembers();
-    //     };
-    //   });
-    // }
-  }
-
-  async createSnapshot(request: CreateSnapshotRequest): Promise<PartySnapshot> {
-    return todo();
-    // assert(request.party_key);
-    // const party = this.echo.getParty(request.party_key) ?? raise(new SpaceNotFoundError(request.party_key));
-    // return party.createSnapshot();
-  }
-}

package/src/packlets/services/service-factory.ts

@@ -1,35 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { Config } from '@dxos/config';
-import { NetworkManager } from '@dxos/network-manager';
-
-import { DevtoolsHostEvents } from '../devtools';
-import { HaloService, PartyService, ProfileService, SystemService, TracingService } from './impl';
-import { DevtoolsService } from './impl/devtools';
-import { ServiceContext } from './service-context';
-import { ClientServices } from './services';
-import { HaloSigner } from './signer';
-
-/**
- * Service factory.
- */
-export const createServices = ({
-  config,
-  context, // TODO(burdon): Too big to pass into services.?
-  signer // TODO(burdon): Remove (legacy?)
-}: {
-  config: Config;
-  context: ServiceContext;
-  networkManager: NetworkManager;
-  signer?: HaloSigner;
-}): ClientServices => ({
-  DataService: context.dataService,
-  HaloService: new HaloService(null, signer), // TODO(burdon): Remove.
-  PartyService: new PartyService(context),
-  ProfileService: new ProfileService(context),
-  SystemService: new SystemService(config),
-  TracingService: new TracingService(config),
-  DevtoolsHost: new DevtoolsService({ events: new DevtoolsHostEvents(), config, context })
-});

package/src/packlets/services/services.ts

@@ -1,39 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-import { schema } from '@dxos/protocols';
-import { PartyService, ProfileService, SystemService, HaloService } from '@dxos/protocols/proto/dxos/client';
-import { DevtoolsHost, TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
-import { DataService } from '@dxos/protocols/proto/dxos/echo/service';
-import { createServiceBundle } from '@dxos/rpc';
-
-// TODO(burdon): Is there a way to mark TS (generics) so cast isn't required for result of stream?
-export type ClientServices = {
-  DataService: DataService;
-  HaloService: HaloService;
-  PartyService: PartyService;
-  ProfileService: ProfileService;
-  SystemService: SystemService;
-
-  DevtoolsHost: DevtoolsHost;
-  TracingService: TracingService;
-};
-
-// TODO(burdon): Rethink name/factory.
-export const clientServiceBundle = createServiceBundle<ClientServices>({
-  DataService: schema.getService('dxos.echo.service.DataService'),
-  HaloService: schema.getService('dxos.client.HaloService'),
-  PartyService: schema.getService('dxos.client.PartyService'),
-  ProfileService: schema.getService('dxos.client.ProfileService'),
-  SystemService: schema.getService('dxos.client.SystemService'),
-
-  DevtoolsHost: schema.getService('dxos.devtools.host.DevtoolsHost'),
-  TracingService: schema.getService('dxos.devtools.host.TracingService')
-});
-
-export interface ClientServiceProvider {
-  services: ClientServices;
-  open(onProgressCallback?: ((progress: any) => void) | undefined): Promise<void>;
-  close(): Promise<void>;
-}

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

@@ -1,87 +0,0 @@
-//
-// 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

@@ -1,28 +0,0 @@
-//
-// 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);
-};