@dxos/client 2.24.1-dev.79448ad7 → 2.25.1-dev.3e7251f9

package/src/client/service-host/services/profile.ts

@@ -9,22 +9,11 @@ import { latch } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { defaultSecretValidator, generatePasscode, SecretProvider } from '@dxos/credentials';
 import { ECHO, InvitationDescriptor } from '@dxos/echo-db';
-import { SubscriptionGroup } from '@dxos/util';
 
 import {
-  InvitationState,
-  ProfileService as IProfileService,
-  AuthenticateInvitationRequest,
-  SubscribeProfileResponse,
-  InvitationRequest,
-  CreateProfileRequest,
-  Contacts,
-  RedeemedInvitation,
-  Profile
-  , RecoverProfileRequest
+  AuthenticateInvitationRequest, CreateProfileRequest, InvitationRequest, InvitationState, Profile, ProfileService as IProfileService, RecoverProfileRequest, RedeemedInvitation, SubscribeProfileResponse
 } from '../../../proto/gen/dxos/client';
 import { InvitationDescriptor as InvitationDescriptorProto } from '../../../proto/gen/dxos/echo/invitation';
-import { resultSetToStream } from '../../../util';
 import { CreateServicesOpts, InviteeInvitation, InviteeInvitations } from './interfaces';
 
 export class ProfileService implements IProfileService {
@@ -32,7 +21,7 @@ export class ProfileService implements IProfileService {
 
   constructor (private echo: ECHO) {}
 
-  SubscribeProfile (): Stream<SubscribeProfileResponse> {
+  subscribeProfile (): Stream<SubscribeProfileResponse> {
     return new Stream(({ next }) => {
       const emitNext = () => next({
         profile: this.echo.halo.isInitialized ? this.echo.halo.getProfile() : undefined
@@ -43,11 +32,11 @@ export class ProfileService implements IProfileService {
     });
   }
 
-  async CreateProfile (request: CreateProfileRequest) {
+  async createProfile (request: CreateProfileRequest) {
     return this.echo.halo.createProfile(request);
   }
 
-  async RecoverProfile (request: RecoverProfileRequest): Promise<Profile> {
+  async recoverProfile (request: RecoverProfileRequest): Promise<Profile> {
     if (!request.seedPhrase) {
       throw new Error('Recovery SeedPhrase not provided.');
     }
@@ -58,7 +47,7 @@ export class ProfileService implements IProfileService {
     return profile;
   }
 
-  CreateInvitation (): Stream<InvitationRequest> {
+  createInvitation (): Stream<InvitationRequest> {
     return new Stream(({ next, close }) => {
       setImmediate(async () => {
         const secret = Buffer.from(generatePasscode());
@@ -82,7 +71,7 @@ export class ProfileService implements IProfileService {
     });
   }
 
-  AcceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
+  acceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
     return new Stream(({ next, close }) => {
       const id = v4();
       const [secretLatch, secretTrigger] = latch();
@@ -112,7 +101,7 @@ export class ProfileService implements IProfileService {
     });
   }
 
-  async AuthenticateInvitation (request: AuthenticateInvitationRequest) {
+  async authenticateInvitation (request: AuthenticateInvitationRequest) {
     assert(request.processId, 'Process ID is missing.');
     const invitation = this.inviteeInvitations.get(request.processId);
     assert(invitation, 'Invitation not found.');
@@ -122,26 +111,6 @@ export class ProfileService implements IProfileService {
     invitation.secret = request.secret;
     invitation.secretTrigger?.();
   }
-
-  SubscribeContacts (): Stream<Contacts> {
-    if (this.echo.halo.isInitialized) {
-      return resultSetToStream(this.echo.halo.queryContacts(), (contacts): Contacts => ({ contacts }));
-    } else {
-      return new Stream(({ next }) => {
-        const subGroup = new SubscriptionGroup();
-
-        setImmediate(async () => {
-          await this.echo.halo.identityReady.waitForCondition(() => this.echo.halo.isInitialized);
-
-          const resultSet = this.echo.halo.queryContacts();
-          next({ contacts: resultSet.value });
-          subGroup.push(resultSet.update.on(() => next({ contacts: resultSet.value })));
-        });
-
-        return () => subGroup.unsubscribe();
-      });
-    }
-  }
 }
 
 export const createProfileService = ({ echo }: CreateServicesOpts): ProfileService => {

package/src/client/service-host/services/services.ts

@@ -3,6 +3,7 @@
 //
 
 import { ClientServices } from '../../../interfaces';
+import { createHaloService } from './halo';
 import { CreateServicesOpts } from './interfaces';
 import { createPartyService } from './party';
 import { createProfileService } from './profile';
@@ -12,13 +13,14 @@ export const createServices = (opts: CreateServicesOpts): Omit<ClientServices, '
   return {
     SystemService: createSystemService(opts),
     ProfileService: createProfileService(opts),
+    HaloService: createHaloService(opts),
     PartyService: createPartyService(opts),
     DataService: opts.echo.dataService,
     TracingService: {
-      SetTracingOptions: () => {
+      setTracingOptions: () => {
         throw new Error('Tracing not available');
       },
-      SubscribeToRpcTrace: () => {
+      subscribeToRpcTrace: () => {
         throw new Error('Tracing not available');
       }
     }

package/src/client/service-host/services/system.ts

@@ -7,7 +7,7 @@ import { CreateServicesOpts } from './interfaces';
 
 export const createSystemService = ({ config, echo }: CreateServicesOpts): SystemService => {
   return {
-    GetConfig: async () => {
+    getConfig: async () => {
       return {
         ...config.values,
         build: {
@@ -16,7 +16,7 @@ export const createSystemService = ({ config, echo }: CreateServicesOpts): Syste
         }
       };
     },
-    Reset: async () => {
+    reset: async () => {
       await echo.reset();
     }
   };

package/src/devtools/devtools-host.ts

@@ -24,68 +24,68 @@ import { resetStorage } from './storage';
 
 export const createDevtoolsHost = (context: DevtoolsServiceDependencies, events: DevtoolsHostEvents) : DevtoolsHost => {
   return {
-    Events: () => {
+    events: () => {
       return new Stream<ClientAPIEvent>(({ next }) => {
         events.ready.on(() => {
           next({ ready: {} });
         });
       });
     },
-    GetConfig: async () => {
+    getConfig: async () => {
       const config = getConfig(context);
       return config;
     },
-    ResetStorage: async () => {
+    resetStorage: async () => {
       await resetStorage(context);
     },
-    EnableDebugLogging: async (request) => {
+    enableDebugLogging: async (request) => {
       enableDebugLogging(context, request);
       return {};
     },
-    DisableDebugLogging: async () => {
+    disableDebugLogging: async () => {
       disableDebugLogging(context);
       return {};
     },
-    SubscribeToKeyringKeys: () => {
+    subscribeToKeyringKeys: () => {
       return subscribeToKeyringKeys(context);
     },
-    SubscribeToCredentialMessages: (request) => {
+    subscribeToCredentialMessages: (request) => {
       return subscribeToCredentialMessages(context, request);
     },
-    SubscribeToParties: () => {
+    subscribeToParties: () => {
       return subscribeToParties(context);
     },
-    SubscribeToItems: () => {
+    subscribeToItems: () => {
       return subscribeToItems(context);
     },
-    SubscribeToFeeds: () => {
+    subscribeToFeeds: () => {
       return subscribeToFeeds(context);
     },
-    SubscribeToFeed: (request) => {
+    subscribeToFeed: (request) => {
       return subscribeToFeed(context, request);
     },
-    GetPartySnapshot: async (request) => {
+    getPartySnapshot: async (request) => {
       return getPartySnapshot(context, request);
     },
-    SavePartySnapshot: async (request) => {
+    savePartySnapshot: async (request) => {
       return savePartySnapshot(context, request);
     },
-    ClearSnapshots: async () => {
+    clearSnapshots: async () => {
       await context.echo.snapshotStore.clear();
     },
-    GetNetworkPeers: async (request) => {
+    getNetworkPeers: async (request) => {
       return getNetworkPeers(context, request);
     },
-    SubscribeToNetworkTopics: () => {
+    subscribeToNetworkTopics: () => {
       return subscribeToNetworkTopics(context);
     },
-    SubscribeToSignalStatus: () => {
+    subscribeToSignalStatus: () => {
       return subscribeToNetworkStatus(context);
     },
-    SubscribeToSignalTrace: () => {
+    subscribeToSignalTrace: () => {
       return subscribeToSignalTrace(context);
     },
-    SubscribeToSwarmInfo: () => {
+    subscribeToSwarmInfo: () => {
       return subscribeToSwarmInfo(context);
     }
   };

package/src/devtools/items.ts

@@ -19,7 +19,7 @@ const getData = (echo: DevtoolsServiceDependencies['echo']): SubscribeToItemsRes
       items: []
     };
 
-    const items = party.database.select(selection => selection.items).getValue();
+    const { result: items } = party.database.select().query();
     for (const item of items) {
       partyInfo.items.push({
         id: item.id,
@@ -48,7 +48,7 @@ export const subscribeToItems = ({ echo }: DevtoolsServiceDependencies) => {
     const unsubscribe = echo.queryParties().subscribe((parties) => {
       parties.forEach(party => {
         if (!partySubscriptions[party.key.toHex()]) {
-          const sub = party.database.select(selection => selection.items).update.on(() => {
+          const sub = party.database.select().query().update.on(() => {
             // Send updates on items changes.
             update();
           });

package/src/index.ts

@@ -9,3 +9,18 @@ export * from './devtools/devtools-context';
 export * from './devtools/devtools-host-events';
 export * from './util';
 export * as proto from './proto/gen';
+
+export {
+  Entity,
+  Item,
+  Link,
+  Database,
+  Selection,
+  SelectionResult,
+  InvitationDescriptor,
+  InvitationDescriptorType,
+  OpenProgress,
+  PartyMember,
+  ResultSet,
+  PARTY_ITEM_TYPE
+} from '@dxos/echo-db';

package/src/interfaces/client-service-provider.ts

@@ -7,13 +7,14 @@ import { DataService, schema as schemaProtocol } from '@dxos/echo-protocol';
 import { createServiceBundle } from '@dxos/rpc';
 
 import { schema } from '../proto/gen';
-import { PartyService, ProfileService, SystemService } from '../proto/gen/dxos/client';
+import { PartyService, ProfileService, SystemService, HaloService } from '../proto/gen/dxos/client';
 import { DevtoolsHost, TracingService } from '../proto/gen/dxos/devtools';
 
 // TODO(burdon): Is there a way to mark TS (generics) so cast isn't required for result of stream?
 export interface ClientServices {
   SystemService: SystemService;
   ProfileService: ProfileService;
+  HaloService: HaloService;
   PartyService: PartyService;
   DataService: DataService;
   DevtoolsHost: DevtoolsHost;
@@ -24,6 +25,7 @@ export const clientServiceBundle = createServiceBundle<ClientServices>({
   SystemService: schema.getService('dxos.client.SystemService'),
   ProfileService: schema.getService('dxos.client.ProfileService'),
   PartyService: schema.getService('dxos.client.PartyService'),
+  HaloService: schema.getService('dxos.client.HaloService'),
   // DataService is provided and implemented internally in ECHO so we import it from there.
   DataService: schemaProtocol.getService('dxos.echo.service.DataService'),
   DevtoolsHost: schema.getService('dxos.devtools.DevtoolsHost'),

package/src/proto/gen/dxos/client.ts

@@ -11,23 +11,8 @@ import * as dxos_halo_keys from "./halo/keys";
 import * as dxos_rpc from "./rpc";
 import * as google_protobuf from "../google/protobuf";
 export interface SystemService {
-    GetConfig: (request: void) => Promise<dxos_config.Config>;
-    Reset: (request: void) => Promise<void>;
-}
-export interface Profile {
-    publicKey: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
-    username?: string;
-}
-export interface SubscribeProfileResponse {
-    profile?: Profile;
-}
-export interface CreateProfileRequest {
-    username?: string;
-    publicKey?: Uint8Array;
-    secretKey?: Uint8Array;
-}
-export interface RecoverProfileRequest {
-    seedPhrase?: string;
+    getConfig: (request: void) => Promise<dxos_config.Config>;
+    reset: (request: void) => Promise<void>;
 }
 export enum InvitationState {
     WAITING_FOR_CONNECTION = 1,
@@ -68,6 +53,21 @@ export interface AuthenticateInvitationRequest {
     processId?: string;
     secret?: Uint8Array;
 }
+export interface Profile {
+    publicKey: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
+    username?: string;
+}
+export interface SubscribeProfileResponse {
+    profile?: Profile;
+}
+export interface CreateProfileRequest {
+    username?: string;
+    publicKey?: Uint8Array;
+    secretKey?: Uint8Array;
+}
+export interface RecoverProfileRequest {
+    seedPhrase?: string;
+}
 export interface Contact {
     publicKey?: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
     displayName?: string;
@@ -76,13 +76,30 @@ export interface Contacts {
     contacts?: Contact[];
 }
 export interface ProfileService {
-    SubscribeProfile: (request: void) => Stream<SubscribeProfileResponse>;
-    CreateProfile: (request: CreateProfileRequest) => Promise<Profile>;
-    RecoverProfile: (request: RecoverProfileRequest) => Promise<Profile>;
-    CreateInvitation: (request: void) => Stream<InvitationRequest>;
-    AcceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
-    AuthenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
-    SubscribeContacts: (request: void) => Stream<Contacts>;
+    subscribeProfile: (request: void) => Stream<SubscribeProfileResponse>;
+    createProfile: (request: CreateProfileRequest) => Promise<Profile>;
+    recoverProfile: (request: RecoverProfileRequest) => Promise<Profile>;
+    createInvitation: (request: void) => Stream<InvitationRequest>;
+    acceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
+    authenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
+}
+export interface AddKeyRecordRequest {
+    keyRecord?: dxos_halo_keys.KeyRecord;
+}
+export interface SignRequest {
+    /**
+     * - The public key of the key that is supposed to be used for signing.
+     */
+    publicKey?: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
+    payload?: ReturnType<typeof substitutions["google.protobuf.Any"]["decode"]>;
+}
+export interface SignResponse {
+    signed?: ReturnType<typeof substitutions["google.protobuf.Any"]["decode"]>;
+}
+export interface HaloService {
+    subscribeContacts: (request: void) => Stream<Contacts>;
+    addKeyRecord: (request: AddKeyRecordRequest) => Promise<void>;
+    sign: (request: SignRequest) => Promise<SignResponse>;
 }
 export interface Party {
     publicKey: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
@@ -138,17 +155,17 @@ export interface CreateSnaspotRequest {
     partyKey?: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
 }
 export interface PartyService {
-    SubscribeToParty: (request: SubscribePartyRequest) => Stream<SubscribePartyResponse>;
-    SubscribeParties: (request: void) => Stream<SubscribePartiesResponse>;
-    CreateParty: (request: void) => Promise<Party>;
-    CloneParty: (request: dxos_echo_snapshot.PartySnapshot) => Promise<Party>;
+    subscribeToParty: (request: SubscribePartyRequest) => Stream<SubscribePartyResponse>;
+    subscribeParties: (request: void) => Stream<SubscribePartiesResponse>;
+    createParty: (request: void) => Promise<Party>;
+    cloneParty: (request: dxos_echo_snapshot.PartySnapshot) => Promise<Party>;
     /**
      * Open and close or activate and deactivate a party.
      */
-    SetPartyState: (request: SetPartyStateRequest) => Promise<Party>;
-    CreateInvitation: (request: CreateInvitationRequest) => Stream<InvitationRequest>;
-    AcceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
-    AuthenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
-    SubscribeMembers: (request: SubscribeMembersRequest) => Stream<SubscribeMembersResponse>;
-    CreateSnapshot: (request: CreateSnaspotRequest) => Promise<dxos_echo_snapshot.PartySnapshot>;
+    setPartyState: (request: SetPartyStateRequest) => Promise<Party>;
+    createInvitation: (request: CreateInvitationRequest) => Stream<InvitationRequest>;
+    acceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
+    authenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
+    subscribeMembers: (request: SubscribeMembersRequest) => Stream<SubscribeMembersResponse>;
+    createSnapshot: (request: CreateSnaspotRequest) => Promise<dxos_echo_snapshot.PartySnapshot>;
 }

package/src/proto/gen/dxos/devtools.ts

@@ -11,25 +11,25 @@ import * as dxos_halo_keys from "./halo/keys";
 import * as dxos_rpc from "./rpc";
 import * as google_protobuf from "../google/protobuf";
 export interface DevtoolsHost {
-    Events: (request: void) => Stream<Event>;
-    GetConfig: (request: void) => Promise<GetConfigResponse>;
-    ResetStorage: (request: ResetStorageRequest) => Promise<void>;
-    EnableDebugLogging: (request: EnableDebugLoggingRequest) => Promise<EnableDebugLoggingResponse>;
-    DisableDebugLogging: (request: EnableDebugLoggingRequest) => Promise<EnableDebugLoggingResponse>;
-    SubscribeToKeyringKeys: (request: SubscribeToKeyringKeysRequest) => Stream<SubscribeToKeyringKeysResponse>;
-    SubscribeToCredentialMessages: (request: SubscribeToCredentialMessagesRequest) => Stream<SubscribeToCredentialMessagesResponse>;
-    SubscribeToParties: (request: SubscribeToPartiesRequest) => Stream<SubscribeToPartiesResponse>;
-    SubscribeToItems: (request: SubscribeToItemsRequest) => Stream<SubscribeToItemsResponse>;
-    SubscribeToFeeds: (request: SubscribeToFeedsRequest) => Stream<SubscribeToFeedsResponse>;
-    SubscribeToFeed: (request: SubscribeToFeedRequest) => Stream<SubscribeToFeedResponse>;
-    GetPartySnapshot: (request: GetPartySnapshotRequest) => Promise<GetPartySnapshotResponse>;
-    SavePartySnapshot: (request: SavePartySnapshotRequest) => Promise<SavePartySnapshotResponse>;
-    ClearSnapshots: (request: ClearSnapshotsRequest) => Promise<void>;
-    GetNetworkPeers: (request: GetNetworkPeersRequest) => Promise<GetNetworkPeersResponse>;
-    SubscribeToNetworkTopics: (request: void) => Stream<SubscribeToNetworkTopicsResponse>;
-    SubscribeToSignalStatus: (request: void) => Stream<SubscribeToSignalStatusResponse>;
-    SubscribeToSignalTrace: (request: void) => Stream<SubscribeToSignalTraceResponse>;
-    SubscribeToSwarmInfo: (request: SubscribeToSwarmInfoRequest) => Stream<SubscribeToSwarmInfoResponse>;
+    events: (request: void) => Stream<Event>;
+    getConfig: (request: void) => Promise<GetConfigResponse>;
+    resetStorage: (request: ResetStorageRequest) => Promise<void>;
+    enableDebugLogging: (request: EnableDebugLoggingRequest) => Promise<EnableDebugLoggingResponse>;
+    disableDebugLogging: (request: EnableDebugLoggingRequest) => Promise<EnableDebugLoggingResponse>;
+    subscribeToKeyringKeys: (request: SubscribeToKeyringKeysRequest) => Stream<SubscribeToKeyringKeysResponse>;
+    subscribeToCredentialMessages: (request: SubscribeToCredentialMessagesRequest) => Stream<SubscribeToCredentialMessagesResponse>;
+    subscribeToParties: (request: SubscribeToPartiesRequest) => Stream<SubscribeToPartiesResponse>;
+    subscribeToItems: (request: SubscribeToItemsRequest) => Stream<SubscribeToItemsResponse>;
+    subscribeToFeeds: (request: SubscribeToFeedsRequest) => Stream<SubscribeToFeedsResponse>;
+    subscribeToFeed: (request: SubscribeToFeedRequest) => Stream<SubscribeToFeedResponse>;
+    getPartySnapshot: (request: GetPartySnapshotRequest) => Promise<GetPartySnapshotResponse>;
+    savePartySnapshot: (request: SavePartySnapshotRequest) => Promise<SavePartySnapshotResponse>;
+    clearSnapshots: (request: ClearSnapshotsRequest) => Promise<void>;
+    getNetworkPeers: (request: GetNetworkPeersRequest) => Promise<GetNetworkPeersResponse>;
+    subscribeToNetworkTopics: (request: void) => Stream<SubscribeToNetworkTopicsResponse>;
+    subscribeToSignalStatus: (request: void) => Stream<SubscribeToSignalStatusResponse>;
+    subscribeToSignalTrace: (request: void) => Stream<SubscribeToSignalTraceResponse>;
+    subscribeToSwarmInfo: (request: SubscribeToSwarmInfoRequest) => Stream<SubscribeToSwarmInfoResponse>;
 }
 export interface Event {
     ready?: ReadyEvent;
@@ -196,6 +196,6 @@ export interface SetTracingOptionsRequest {
     enable?: boolean;
 }
 export interface TracingService {
-    SetTracingOptions: (request: SetTracingOptionsRequest) => Promise<void>;
-    SubscribeToRpcTrace: (request: void) => Stream<dxos_rpc.RpcMessage>;
+    setTracingOptions: (request: SetTracingOptionsRequest) => Promise<void>;
+    subscribeToRpcTrace: (request: void) => Stream<dxos_rpc.RpcMessage>;
 }

package/src/proto/gen/dxos/echo/service.ts

@@ -47,7 +47,7 @@ export interface MutationReceipt {
     seq?: number;
 }
 export interface DataService {
-    SubscribeEntitySet: (request: SubscribeEntitySetRequest) => Stream<SubscribeEntitySetResponse>;
-    SubscribeEntityStream: (request: SubscribeEntityStreamRequest) => Stream<SubscribeEntityStreamResponse>;
-    Write: (request: WriteRequest) => Promise<MutationReceipt>;
+    subscribeEntitySet: (request: SubscribeEntitySetRequest) => Stream<SubscribeEntitySetResponse>;
+    subscribeEntityStream: (request: SubscribeEntityStreamRequest) => Stream<SubscribeEntityStreamResponse>;
+    write: (request: WriteRequest) => Promise<MutationReceipt>;
 }

package/src/proto/gen/google/protobuf.ts

@@ -10,6 +10,8 @@ import * as dxos_echo_service from "../dxos/echo/service";
 import * as dxos_echo_snapshot from "../dxos/echo/snapshot";
 import * as dxos_halo_keys from "../dxos/halo/keys";
 import * as dxos_rpc from "../dxos/rpc";
+export interface Empty {
+}
 export interface Timestamp {
     seconds?: string;
     nanos?: number;
@@ -255,8 +257,6 @@ export namespace GeneratedCodeInfo {
         end?: number;
     }
 }
-export interface Empty {
-}
 export interface Any {
     type_url?: string;
     value?: Uint8Array;