@dxos/client 2.31.8-dev.f21022f7 → 2.32.1-dev.0d16db2c

package/src/api/client.test.ts

@@ -12,6 +12,7 @@ import { ConfigObject } from '@dxos/config';
 import { generateSeedPhrase, keyPairFromSeedPhrase } from '@dxos/crypto';
 import { throwUnhandledRejection } from '@dxos/debug';
 import { InvitationDescriptor } from '@dxos/echo-db';
+import { Timeframe } from '@dxos/echo-protocol';
 import { TestModel } from '@dxos/model-factory';
 import { ObjectModel } from '@dxos/object-model';
 import { createBundledRpcServer, createLinkedPorts } from '@dxos/rpc';
@@ -265,6 +266,24 @@ describe('Client', () => {
 
         expect(item1.model.get('prop1')).toEqual('x');
       });
+
+      test('party timeframe is incremented after creating ECHO mutations', async () => {
+        const client = await createClient();
+        await client.initialize();
+        afterTest(() => client.destroy());
+
+        await client.halo.createProfile();
+        const party = await client.echo.createParty();
+
+        const item1 = await party.database.createItem({ model: ObjectModel, type: 'test' });
+        await item1.model.set('prop1', 'x');
+        const item2 = await party.database.createItem({ model: ObjectModel, type: 'test' });
+        await item2.model.set('prop1', 'y');
+
+        const details = await party.getDetails();
+        expect(details.processedTimeframe).toBeInstanceOf(Timeframe);
+        expect(details.processedTimeframe.frames().some(([key, seq]) => seq > 0)).toBe(true);
+      });
     });
   }
 

package/src/api/client.ts

@@ -12,7 +12,7 @@ import { OpenProgress } from '@dxos/echo-db';
 import { ModelConstructor } from '@dxos/model-factory';
 import { RpcPort } from '@dxos/rpc';
 
-import { DevtoolsHook } from '../devtools';
+import { createDevtoolsRpcServer } from '../devtools';
 import { Runtime } from '../proto/gen/dxos/config';
 import { ClientServiceProvider, ClientServices, ClientServiceHost, ClientServiceProxy, HaloSigner } from '../services';
 import { createWindowMessagePort, isNode } from '../util';
@@ -47,6 +47,11 @@ export interface ClientOptions {
    *
    */
   signer?: HaloSigner
+
+  /**
+   *
+   */
+  timeout?: number
 }
 
 /**
@@ -173,6 +178,10 @@ export class Client {
       await this.initializeAuto(onProgressCallback);
     }
 
+    if (typeof window !== 'undefined') {
+      await createDevtoolsRpcServer(this, this._serviceProvider);
+    }
+
     this._halo = new HaloProxy(this._serviceProvider);
     this._echo = new EchoProxy(this._serviceProvider, this._halo);
 
@@ -189,7 +198,10 @@ export class Client {
     }
 
     log('Creating client proxy.');
-    this._serviceProvider = new ClientServiceProxy(this._options.rpcPort ?? createWindowMessagePort());
+    this._serviceProvider = new ClientServiceProxy(
+      this._options.rpcPort ?? createWindowMessagePort(),
+      this._options.timeout
+    );
     await this._serviceProvider.open(onProgressCallback);
   }
 
@@ -253,19 +265,4 @@ export class Client {
     this._echo.modelFactory.registerModel(constructor);
     return this;
   }
-
-  /**
-   * Returns devtools context.
-   * Used by the DXOS DevTool Extension.
-   * This is what gets assigned to `window.__DXOS__` global.
-   */
-  getDevtoolsContext (): DevtoolsHook {
-    const devtoolsContext: DevtoolsHook = {
-      client: this,
-      // TODO(dmaretskyi): Is serviceHost needed?
-      serviceHost: this._serviceProvider
-    };
-
-    return devtoolsContext;
-  }
 }

package/src/api/proxies/party-proxy.ts

@@ -18,7 +18,7 @@ import { PartyKey, PartySnapshot } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { ObjectModel, ObjectProperties } from '@dxos/object-model';
 
-import { Party as PartyProto } from '../../proto/gen/dxos/client';
+import { Party as PartyProto, PartyDetails } from '../../proto/gen/dxos/client';
 import { ClientServiceHost, ClientServiceProvider, ClientServiceProxy } from '../../services';
 import { streamToResultSet } from '../../util';
 import { InvitationRequest, InvitationProxy } from '../invitations';
@@ -51,6 +51,8 @@ export interface Party {
   setTitle (title: string): Promise<void>
   getTitle (): string
 
+  getDetails(): Promise<PartyDetails>
+
   get properties (): ObjectProperties
   /**
    * @deprecated
@@ -179,6 +181,10 @@ export class PartyProxy implements Party {
     await this._setOpen(false);
   }
 
+  async getDetails (): Promise<PartyDetails> {
+    return this._serviceProvider.services.PartyService.getPartyDetails({ partyKey: this._key });
+  }
+
   async _setOpen (open: boolean) {
     await this._serviceProvider.services.PartyService.setPartyState({
       partyKey: this.key,

package/src/devtools/devtools-context.ts

@@ -10,15 +10,13 @@ import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 
 import { Client } from '../api';
-import { ClientServiceProvider } from '../services';
 
 /**
  * A hook bound to window.__DXOS__.
  */
 export interface DevtoolsHook {
-  // TODO(marik-d): Reduce to just exporting ClientServices.
-  serviceHost: ClientServiceProvider
   client: Client
+  openClientRpcServer: () => Promise<boolean>
 }
 
 export interface DevtoolsServiceDependencies {

package/src/devtools/devtools-rpc-server.ts

@@ -0,0 +1,73 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import debug from 'debug';
+
+import { createBundledRpcServer, RpcPeer, RpcPort } from '@dxos/rpc';
+
+import { Client } from '../api';
+import { clientServiceBundle, ClientServiceProvider } from '../services';
+import { DevtoolsHook } from './devtools-context';
+
+const log = debug('dxos:client:devtools');
+const error = log.extend('error');
+
+const port: RpcPort = {
+  send: async message => window.postMessage({
+    data: Array.from(message),
+    source: 'dxos-client'
+  }, '*'),
+  subscribe: callback => {
+    const handler = (event: MessageEvent<any>) => {
+      if (event.source !== window) {
+        return;
+      }
+
+      const message = event.data;
+
+      if (
+        typeof message !== 'object' ||
+        message === null ||
+        message.source !== 'content-script'
+      ) {
+        return;
+      }
+
+      callback(new Uint8Array(message.data));
+    };
+
+    window.addEventListener('message', handler);
+    return () => window.removeEventListener('message', handler);
+  }
+};
+
+// Console debug access.
+// TODO(burdon): Debug only.
+export const createDevtoolsRpcServer = async (client: Client, serviceHost: ClientServiceProvider) => {
+  let server: RpcPeer;
+  ((window as any).__DXOS__ as DevtoolsHook) = {
+    client,
+    openClientRpcServer: async () => {
+      if (server) {
+        log('Closing existing client RPC server.');
+        server.close();
+      }
+
+      log('Opening devtools client RPC server...');
+      server = createBundledRpcServer({
+        services: clientServiceBundle,
+        handlers: serviceHost.services,
+        port
+      });
+
+      await server.open().catch(err => {
+        error(`Failed to open RPC server: ${err}`);
+        return false;
+      });
+      log('Opened devtools client RPC server.');
+
+      return true;
+    }
+  };
+};

package/src/devtools/index.ts

@@ -5,3 +5,4 @@
 export * from './devtools-context';
 export * from './devtools-host';
 export * from './devtools-host-events';
+export * from './devtools-rpc-server';

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

@@ -130,6 +130,15 @@ export namespace Party {
 export interface SubscribePartyRequest {
     partyKey: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
 }
+export interface GetPartyDetailsRequest {
+    partyKey: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
+}
+export interface PartyDetails {
+    /**
+     * The timeframe of mutations processed by the client.
+     */
+    processedTimeframe: ReturnType<typeof substitutions["dxos.echo.feed.TimeframeVector"]["decode"]>;
+}
 export interface SubscribePartyResponse {
     party?: Party;
 }
@@ -171,6 +180,7 @@ export interface CreateSnaspotRequest {
 export interface PartyService {
     subscribeToParty: (request: SubscribePartyRequest) => Stream<SubscribePartyResponse>;
     subscribeParties: (request: void) => Stream<SubscribePartiesResponse>;
+    getPartyDetails: (request: GetPartyDetailsRequest) => Promise<PartyDetails>;
     createParty: (request: void) => Promise<Party>;
     cloneParty: (request: dxos_echo_snapshot.PartySnapshot) => Promise<Party>;
     /**

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

@@ -14,9 +14,13 @@ export interface RpcMessage {
     request?: Request;
     response?: Response;
     /**
-     * Means that the node is open to receiving requests. Second stage of the hasnshake protocol.
+     * Means that the node is trying to open the connection.
      */
     open?: boolean;
+    /**
+     * Means that the node has received the "open" message and is ready to perform requests.
+     */
+    openAck?: boolean;
     streamClose?: StreamClose;
 }
 export interface Request {

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

@@ -12,14 +12,14 @@ import * as dxos_halo_keys from "../dxos/halo/keys";
 import * as dxos_rpc from "../dxos/rpc";
 export interface Empty {
 }
-export interface Any {
-    type_url?: string;
-    value?: Uint8Array;
-}
 export interface Timestamp {
     seconds?: string;
     nanos?: number;
 }
+export interface Any {
+    type_url?: string;
+    value?: Uint8Array;
+}
 export interface FileDescriptorSet {
     file?: FileDescriptorProto[];
 }