@dxos/client-services 0.1.2 → 0.1.3

package/src/packlets/{invitations/common.ts → deprecated/invitations.ts}

@@ -4,6 +4,10 @@
 
 import { defaultSecretProvider, defaultSecretValidator, SecretProvider, SecretValidator } from '@dxos/credentials';
 
+//
+// TODO(burdon): Deprecated pending new invitations.
+//
+
 /**
  * Defines a way for peers to authenticate each other through a side channel.
  */
@@ -18,7 +22,7 @@ export const defaultInvitationAuthenticator: Required<InvitationAuthenticator> =
 };
 
 /**
- * Additional set of callbacks and options used in the invitation process.
+ * @deprecated
  */
 export interface InvitationOptions {
   /**
@@ -32,17 +36,28 @@ export interface InvitationOptions {
   expiration?: number;
 }
 
-// TODO(burdon): Remove/move to API.
+/**
+ * @deprecated
+ */
 export type InviterInvitation = {
   invitationCode: string;
   secret: Uint8Array | undefined;
 };
 
-// TODO(burdon): Remove/move to API.
+/**
+ * @deprecated
+ */
 export type InviteeInvitation = {
   secret?: Uint8Array | undefined; // Can be undefined initially, then set after receiving secret from the inviter.
   secretTrigger?: () => void; // Is triggered after supplying the secret.
 };
 
+/**
+ * @deprecated
+ */
 export type InviterInvitations = InviterInvitation[];
+
+/**
+ * @deprecated
+ */
 export type InviteeInvitations = Map<string, InviteeInvitation>;

package/src/packlets/{services/impl → deprecated}/profile.ts

@@ -15,20 +15,20 @@ import {
   InvitationRequest,
   InvitationState,
   Profile,
-  ProfileService as ProfileServiceRpc,
+  ProfileService,
   RecoverProfileRequest,
   RedeemedInvitation,
   SubscribeProfileResponse
 } from '@dxos/protocols/proto/dxos/client';
-import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
-import { InviteeInvitation, InviteeInvitations } from '../../invitations';
-import { ServiceContext } from '../service-context';
+import { ServiceContext } from '../services';
+import { InviteeInvitation, InviteeInvitations } from './invitations';
 
 /**
  * Profile service implementation.
  */
-export class ProfileService implements ProfileServiceRpc {
+export class ProfileServiceImpl implements ProfileService {
   private inviteeInvitations: InviteeInvitations = new Map();
 
   constructor(private readonly context: ServiceContext) {}
@@ -39,7 +39,7 @@ export class ProfileService implements ProfileServiceRpc {
         next({
           profile: this.context.identityManager.identity
             ? {
-                publicKey: this.context.identityManager.identity.identityKey
+                identityKey: this.context.identityManager.identity.identityKey
               }
             : undefined
         });
@@ -51,7 +51,7 @@ export class ProfileService implements ProfileServiceRpc {
 
   async createProfile(request: CreateProfileRequest): Promise<Profile> {
     await this.context.createIdentity();
-    return { publicKey: this.context.identityManager.identity!.identityKey };
+    return { identityKey: this.context.identityManager.identity!.identityKey };
   }
 
   async recoverProfile(request: RecoverProfileRequest): Promise<Profile> {
@@ -69,7 +69,7 @@ export class ProfileService implements ProfileServiceRpc {
   createInvitation(): Stream<InvitationRequest> {
     return new Stream(({ next, close }) => {
       setTimeout(async () => {
-        const secret = Buffer.from(generatePasscode());
+        const authenticationCode = generatePasscode();
         // TODO(burdon): Not used.
         // const secretProvider = async () => {
         //   next({ descriptor: invitation.toProto(), state: InvitationState.CONNECTED });
@@ -82,7 +82,7 @@ export class ProfileService implements ProfileServiceRpc {
             close();
           }
         });
-        invitation.secret = secret;
+        invitation.authenticationCode = authenticationCode;
 
         next({
           state: InvitationState.WAITING_FOR_CONNECTION,
@@ -92,7 +92,7 @@ export class ProfileService implements ProfileServiceRpc {
     });
   }
 
-  acceptInvitation(invitation: InvitationDescriptor): Stream<RedeemedInvitation> {
+  acceptInvitation(invitation: Invitation): Stream<RedeemedInvitation> {
     return new Stream(({ next, close }) => {
       const id = v4();
       const [, secretTrigger] = latch();
@@ -110,16 +110,16 @@ export class ProfileService implements ProfileServiceRpc {
       // };
 
       // Joining process is kicked off, and will await authentication with a secret.
-      const haloPartyPromise = this.context.haloInvitations.acceptInvitation(invitation);
+      const haloSpacePromise = this.context.haloInvitations.acceptInvitation(invitation);
       this.inviteeInvitations.set(id, inviteeInvitation);
       next({ id, state: InvitationState.CONNECTED });
 
-      haloPartyPromise
+      haloSpacePromise
         .then((identity) => {
           next({
             id,
             state: InvitationState.SUCCESS,
-            partyKey: identity.identityKey
+            spaceKey: identity.identityKey
           });
         })
         .catch((err) => {

package/src/packlets/deprecated/space.ts

@@ -0,0 +1,245 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { EventSubscriptions } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { todo } from '@dxos/debug';
+import {
+  AuthenticateInvitationRequest,
+  CreateSnapshotRequest,
+  GetSpaceDetailsRequest,
+  Space,
+  SpaceDetails,
+  SpaceService,
+  SetSpaceStateRequest,
+  SubscribeMembersRequest,
+  SubscribeMembersResponse,
+  SubscribeSpacesResponse,
+  SubscribeSpaceRequest,
+  SubscribeSpaceResponse
+} from '@dxos/protocols/proto/dxos/client';
+import { SpaceSnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
+import { humanize } from '@dxos/util';
+
+import { ServiceContext } from '../services';
+import { InviteeInvitations } from './invitations';
+
+/**
+ * Space service implementation.
+ * @deprecated
+ */
+export class SpaceServiceImpl implements SpaceService {
+  private inviteeInvitations: InviteeInvitations = new Map();
+
+  constructor(private readonly serviceContext: ServiceContext) {}
+
+  subscribeToSpace(request: SubscribeSpaceRequest): Stream<SubscribeSpaceResponse> {
+    return new Stream(({ next }) => {
+      next({
+        space: {
+          publicKey: request.spaceKey,
+          isOpen: true,
+          isActive: true,
+          members: []
+        }
+      });
+    });
+
+    // const update = (next: (message: SubscribeSpaceResponse) => void) => {
+    //   try {
+    //     const space = this.echo.getSpace(request.space_key);
+    //     next({
+    //       space: space && {
+    //         public_key: space.key,
+    //         is_open: space.is_open,
+    //         is_active: space.is_active,
+    //         members: space.queryMembers().value
+    //       }
+    //     });
+    //   } catch (err) {
+    //     if (err instanceof InvalidStateError) {
+    //       // Do nothing.
+    //     } else {
+    //       throw err;
+    //     }
+    //   }
+    // };
+
+    // const space = this.serviceContext.brane.getSpace(request.space_key);
+    // if (space) {
+    //   return new Stream(({ next }) => space.update.on(() => update(next)));
+    // } else {
+    //   return new Stream(({ next }) => {
+    //     let unsubscribeSpace: () => void;
+    //     const unsubscribeSpaces = this.echo.querySpaces().subscribe((spaces) => {
+    //       const space = spaces.find((space) => space.key.equals(request.space_key));
+    //       if (space && !unsubscribeSpace) {
+    //         unsubscribeSpace = space.update.on(() => update(next));
+    //       }
+    //     });
+
+    //     update(next);
+
+    //     return () => {
+    //       unsubscribeSpaces();
+    //       unsubscribeSpace?.();
+    //     };
+    //   });
+    // }
+  }
+
+  subscribeSpaces() {
+    return new Stream<SubscribeSpacesResponse>(({ next }) => {
+      const subscriptions = new EventSubscriptions();
+
+      const onUpdate = () => {
+        next({
+          spaces: Array.from(this.serviceContext.spaceManager!.spaces.values()).map(
+            (space): Space => ({
+              publicKey: space.key,
+              isOpen: true,
+              isActive: true,
+              members: Array.from(space.spaceState.members.values()).map((member) => ({
+                identityKey: member.key,
+                profile: {
+                  identityKey: member.key,
+                  displayName: humanize(member.key)
+                }
+              }))
+            })
+          )
+        });
+      };
+
+      setTimeout(async () => {
+        if (!this.serviceContext.spaceManager) {
+          next({ spaces: [] });
+        }
+
+        await this.serviceContext.initialized.wait();
+
+        subscriptions.add(
+          this.serviceContext.spaceManager!.updated.on(() => {
+            this.serviceContext.spaceManager!.spaces.forEach((space) => {
+              subscriptions.add(space.stateUpdate.on(onUpdate));
+            });
+            onUpdate();
+          })
+        );
+
+        onUpdate();
+      });
+
+      return () => subscriptions.clear();
+    });
+  }
+
+  async getSpaceDetails(request: GetSpaceDetailsRequest): Promise<SpaceDetails> {
+    return todo();
+    // const space = this.echo.getSpace(request.space_key) ?? raise(new SpaceNotFoundError(request.space_key));
+    // return {
+    //   processedTimeframe: space.timeframe
+    // };
+  }
+
+  async createSpace(): Promise<Space> {
+    await this.serviceContext.initialized.wait();
+    const space = await this.serviceContext.spaceManager!.createSpace();
+    return {
+      publicKey: space.key,
+      isOpen: true,
+      isActive: true
+    };
+  }
+
+  async cloneSpace(snapshot: SpaceSnapshot): Promise<Space> {
+    return todo();
+    // const space = await this.echo.cloneSpace(snapshot);
+    // return {
+    //   public_key: space.key,
+    //   is_open: space.is_open,
+    //   is_active: space.is_active
+    // };
+  }
+
+  async setSpaceState(request: SetSpaceStateRequest) {
+    return todo();
+    // const space = this.echo.getSpace(request.space_key);
+    // if (!space) {
+    //   throw new Error('Space not found');
+    // }
+
+    // if (request.open === true) {
+    //   await space.open();
+    // } else if (request.open === false) {
+    //   await space.close();
+    // } // Undefined preserves previous state.
+
+    // if (request.active_global === true) {
+    //   await space.activate({ global: true });
+    // } else if (request.active_global === false) {
+    //   await space.deactivate({ global: true });
+    // } // Undefined preserves previous state.
+
+    // if (request.active_device === true) {
+    //   await space.activate({ device: true });
+    // } else if (request.active_device === false) {
+    //   await space.deactivate({ device: true });
+    // } // Undefined preserves previous state.
+    // return {
+    //   public_key: space.key,
+    //   is_open: space.is_open,
+    //   is_active: space.is_active
+    // };
+  }
+
+  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 space = this.echo.getSpace(request.space_key);
+    // if (space) {
+    //   return resultSetToStream(space.queryMembers(), (members): SubscribeMembersResponse => ({ members }));
+    // } else {
+    //   return new Stream(({ next }) => {
+    //     let unsubscribeMembers: () => void;
+    //     const unsubscribeSpaces = this.echo.querySpaces().subscribe((spaces) => {
+    //       const space = spaces.find((space) => space.key.equals(request.space_key));
+    //       if (!unsubscribeMembers && space) {
+    //         const resultSet = space.queryMembers();
+    //         next({ members: resultSet.value });
+    //         unsubscribeMembers = resultSet.update.on(() => next({ members: resultSet.value }));
+    //       }
+    //     });
+
+    //     return () => {
+    //       unsubscribeSpaces();
+    //       unsubscribeMembers();
+    //     };
+    //   });
+    // }
+  }
+
+  async createSnapshot(request: CreateSnapshotRequest): Promise<SpaceSnapshot> {
+    return todo();
+    // assert(request.space_key);
+    // const space = this.echo.getSpace(request.space_key) ?? raise(new SpaceNotFoundError(request.space_key));
+    // return space.createSnapshot();
+  }
+}

package/src/packlets/{services/impl → deprecated}/system.ts

@@ -4,9 +4,9 @@
 
 import { Config } from '@dxos/config';
 import { todo } from '@dxos/debug';
-import { SystemService as SystemServiceRpc } from '@dxos/protocols/proto/dxos/client';
+import { SystemService } from '@dxos/protocols/proto/dxos/client';
 
-export class SystemService implements SystemServiceRpc {
+export class SystemServiceImpl implements SystemService {
   constructor(private readonly _config: Config) {}
 
   async getConfig(request: void) {

package/src/packlets/{services/impl → deprecated}/tracing.ts

@@ -3,12 +3,12 @@
 //
 
 import { Config } from '@dxos/config';
-import { TracingService as TracingServiceRpc } from '@dxos/protocols/proto/dxos/devtools/host';
+import { TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
 
 /**
  *
  */
-export class TracingService implements TracingServiceRpc {
+export class TracingServiceImpl implements TracingService {
   constructor(private readonly _config: Config) {}
 
   async setTracingOptions() {

package/src/packlets/{services/impl → devtools}/devtools.ts

@@ -2,23 +2,23 @@
 // Copyright 2022 DXOS.org
 //
 
+import { Event as AsyncEvent } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { Config } from '@dxos/config';
-import { todo } from '@dxos/debug';
 import {
   ClearSnapshotsRequest,
-  DevtoolsHost,
+  DevtoolsHost, // TODO(burdon): Rename DevtoolsService
   EnableDebugLoggingRequest,
   EnableDebugLoggingResponse,
   Event,
   GetConfigResponse,
   GetNetworkPeersRequest,
   GetNetworkPeersResponse,
-  GetPartySnapshotRequest,
-  GetPartySnapshotResponse,
+  GetSpaceSnapshotRequest,
+  GetSpaceSnapshotResponse,
   ResetStorageRequest,
-  SavePartySnapshotRequest,
-  SavePartySnapshotResponse,
+  SaveSpaceSnapshotRequest,
+  SaveSpaceSnapshotResponse,
   SubscribeToCredentialMessagesRequest,
   SubscribeToCredentialMessagesResponse,
   SubscribeToFeedBlocksRequest,
@@ -30,23 +30,22 @@ import {
   SubscribeToKeyringKeysRequest,
   SubscribeToKeyringKeysResponse,
   SubscribeToNetworkTopicsResponse,
-  SubscribeToPartiesRequest,
-  SubscribeToPartiesResponse,
+  SubscribeToSpacesRequest,
+  SubscribeToSpacesResponse,
   SubscribeToSignalStatusResponse,
   SubscribeToSignalTraceResponse,
   SubscribeToSwarmInfoResponse
 } from '@dxos/protocols/proto/dxos/devtools/host';
 
-import {
-  DevtoolsHostEvents,
-  subscribeToNetworkStatus,
-  subscribeToSignalTrace,
-  subscribeToSwarmInfo,
-  subscribeToSpaces,
-  subscribeToFeedBlocks,
-  subscribeToFeeds
-} from '../../devtools';
-import { ServiceContext } from '../service-context';
+import { ServiceContext } from '../services';
+import { subscribeToFeedBlocks, subscribeToFeeds } from './feeds';
+import { subscribeToNetworkStatus, subscribeToSignalTrace, subscribeToSwarmInfo } from './network';
+import { subscribeToSpaces } from './spaces';
+
+// TODO(burdon): Remove?
+export class DevtoolsHostEvents {
+  readonly ready = new AsyncEvent();
+}
 
 export type DevtoolsServiceParams = {
   events: DevtoolsHostEvents;
@@ -54,7 +53,7 @@ export type DevtoolsServiceParams = {
   context: ServiceContext;
 };
 
-export class DevtoolsService implements DevtoolsHost {
+export class DevtoolsServiceImpl implements DevtoolsHost {
   constructor(private readonly params: DevtoolsServiceParams) {}
 
   events(request: void): Stream<Event> {
@@ -66,37 +65,37 @@ export class DevtoolsService implements DevtoolsHost {
   }
 
   getConfig(request: void): Promise<GetConfigResponse> {
-    todo();
+    throw new Error();
   }
 
   resetStorage(request: ResetStorageRequest): Promise<void> {
-    todo();
+    throw new Error();
   }
 
   enableDebugLogging(request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
-    todo();
+    throw new Error();
   }
 
   disableDebugLogging(request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToKeyringKeys(request: SubscribeToKeyringKeysRequest): Stream<SubscribeToKeyringKeysResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToCredentialMessages(
     request: SubscribeToCredentialMessagesRequest
   ): Stream<SubscribeToCredentialMessagesResponse> {
-    todo();
+    throw new Error();
   }
 
-  subscribeToParties(request: SubscribeToPartiesRequest): Stream<SubscribeToPartiesResponse> {
+  subscribeToSpaces(request: SubscribeToSpacesRequest): Stream<SubscribeToSpacesResponse> {
     return subscribeToSpaces(this.params.context, request);
   }
 
   subscribeToItems(request: SubscribeToItemsRequest): Stream<SubscribeToItemsResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToFeeds(request: SubscribeToFeedsRequest): Stream<SubscribeToFeedsResponse> {
@@ -107,24 +106,24 @@ export class DevtoolsService implements DevtoolsHost {
     return subscribeToFeedBlocks({ feedStore: this.params.context.feedStore }, request);
   }
 
-  getPartySnapshot(request: GetPartySnapshotRequest): Promise<GetPartySnapshotResponse> {
-    todo();
+  getSpaceSnapshot(request: GetSpaceSnapshotRequest): Promise<GetSpaceSnapshotResponse> {
+    throw new Error();
   }
 
-  savePartySnapshot(request: SavePartySnapshotRequest): Promise<SavePartySnapshotResponse> {
-    todo();
+  saveSpaceSnapshot(request: SaveSpaceSnapshotRequest): Promise<SaveSpaceSnapshotResponse> {
+    throw new Error();
   }
 
   clearSnapshots(request: ClearSnapshotsRequest): Promise<void> {
-    todo();
+    throw new Error();
   }
 
   getNetworkPeers(request: GetNetworkPeersRequest): Promise<GetNetworkPeersResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToNetworkTopics(request: void): Stream<SubscribeToNetworkTopicsResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToSignalStatus(request: void): Stream<SubscribeToSignalStatusResponse> {

package/src/packlets/devtools/feeds.ts

@@ -27,14 +27,15 @@ export const subscribeToFeeds = (
     const feedMap = new ComplexMap<PublicKey, FeedWrapper<FeedMessage>>(PublicKey.hash);
     const subscriptions = new EventSubscriptions();
 
-    const update = async () => {
-      const feeds = await feedStore.feeds;
+    const update = () => {
+      const feeds = feedStore.feeds;
       feeds
         .filter((feed) => !feedKeys?.length || feedKeys.some((feedKey) => feedKey.equals(feed.key)))
         .forEach((feed) => {
           if (!feedMap.has(feed.key)) {
             feedMap.set(feed.key, feed);
-            feed.on('close', update); // TODO(mykola): Unsubscribe.
+            feed.on('close', update);
+            subscriptions.add(feed.off('close', update));
           }
         });
       next({
@@ -42,10 +43,8 @@ export const subscribeToFeeds = (
       });
     };
 
-    setImmediate(async () => {
-      subscriptions.add(feedStore.feedOpened.on(update));
-      await update();
-    });
+    subscriptions.add(feedStore.feedOpened.on(update));
+    update();
 
     return () => {
       subscriptions.clear();
@@ -60,31 +59,36 @@ export const subscribeToFeedBlocks = (
     if (!feedKey) {
       return;
     }
-
-    const update = async (feed: FeedWrapper<FeedMessage>) => {
-      const iterator = new FeedIterator(feed);
-      await iterator.open();
-      const blocks = [];
-      for await (const block of iterator) {
-        blocks.push(block);
-        if (blocks.length >= feed.properties.length) {
-          break;
-        }
-      }
-      next({
-        blocks: blocks.slice(-maxBlocks)
-      });
-      await iterator.close();
-    };
+    const subscriptions = new EventSubscriptions();
 
     setImmediate(async () => {
-      const feed = await feedStore.getFeed(feedKey);
+      const feed = feedStore.getFeed(feedKey);
       if (!feed) {
         return;
       }
-      feed.on('append', () => update(feed)); // TODO(mykola): Unsubscribe.
-      feed.on('truncate', () => update(feed)); // TODO(mykola): Unsubscribe.
-      await update(feed);
+
+      const update = async () => {
+        const iterator = new FeedIterator(feed);
+        await iterator.open();
+        const blocks = [];
+        for await (const block of iterator) {
+          blocks.push(block);
+          if (blocks.length >= feed.properties.length) {
+            break;
+          }
+        }
+        next({
+          blocks: blocks.slice(-maxBlocks)
+        });
+        await iterator.close();
+      };
+
+      feed.on('append', update);
+      subscriptions.add(feed.off('append', update));
+
+      feed.on('truncate', update);
+      subscriptions.add(feed.off('truncate', update));
+      await update();
     });
 
     return () => {};

package/src/packlets/devtools/index.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './devtools-host-events';
+export * from './devtools';
 export * from './feeds';
 export * from './network';
 export * from './spaces';