@dxos/client-services 0.8.3 → 0.8.4-main.03d5cd7b56

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+import { type Context } from '@dxos/context';
 import {
   createCancelDelegatedSpaceInvitationCredential,
   createDelegatedSpaceInvitationCredential,
@@ -12,24 +13,18 @@ import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import {
-  AlreadyJoinedError,
-  type ApiError,
-  AuthorizationError,
-  InvalidInvitationError,
-  SpaceNotFoundError,
-} from '@dxos/protocols';
+import { AlreadyJoinedError, AuthorizationError, InvalidInvitationError, SpaceNotFoundError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type ProfileDocument, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionRequest,
   type AdmissionResponse,
   type IntroductionRequest,
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 
+import { type DataSpaceManager, type SigningContext } from '../spaces';
 import { type InvitationProtocol } from './invitation-protocol';
 import { computeExpirationTime } from './utils';
-import { type DataSpaceManager, type SigningContext } from '../spaces';
 
 export class SpaceInvitationProtocol implements InvitationProtocol {
   constructor(
@@ -47,16 +42,16 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  checkCanInviteNewMembers(): ApiError | undefined {
+  checkCanInviteNewMembers(): Error | undefined {
     if (this._spaceKey == null) {
-      return new InvalidInvitationError('No spaceKey was provided for a space invitation.');
+      return new InvalidInvitationError({ message: 'No spaceKey was provided for a space invitation.' });
     }
     const space = this._spaceManager.spaces.get(this._spaceKey);
     if (space == null) {
       return new SpaceNotFoundError(this._spaceKey);
     }
     if (!space?.inner.spaceState.hasMembershipManagementPermission(this._signingContext.identityKey)) {
-      return new AuthorizationError('No member management permission.');
+      return new AuthorizationError({ message: 'No member management permission.' });
     }
     return undefined;
   }
@@ -147,10 +142,10 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
 
   checkInvitation(invitation: Partial<Invitation>): InvalidInvitationError | AlreadyJoinedError | undefined {
     if (invitation.spaceKey == null) {
-      return new InvalidInvitationError('No spaceKey was provided for a space invitation.');
+      return new InvalidInvitationError({ message: 'No spaceKey was provided for a space invitation.' });
     }
     if (this._spaceManager.spaces.has(invitation.spaceKey)) {
-      return new AlreadyJoinedError('Already joined space.');
+      return new AlreadyJoinedError({ message: 'Already joined space.' });
     }
   }
 
@@ -175,7 +170,7 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  async accept(response: AdmissionResponse): Promise<Partial<Invitation>> {
+  async accept(ctx: Context, response: AdmissionResponse): Promise<Partial<Invitation>> {
     invariant(response.space);
     const { credential, controlTimeframe, dataTimeframe } = response.space;
     const assertion = getCredentialAssertion(credential);
@@ -183,15 +178,16 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     invariant(credential.subject.id.equals(this._signingContext.identityKey));
 
     if (this._spaceManager.spaces.has(assertion.spaceKey)) {
-      throw new AlreadyJoinedError('Already joined space.');
+      throw new AlreadyJoinedError({ message: 'Already joined space.' });
     }
 
     // Create local space.
-    await this._spaceManager.acceptSpace({
+    await this._spaceManager.acceptSpace(ctx, {
       spaceKey: assertion.spaceKey,
       genesisFeedKey: assertion.genesisFeedKey,
       controlTimeframe,
       dataTimeframe,
+      tags: assertion.tags,
     });
 
     await this._signingContext.recordCredential(credential);

package/src/packlets/invitations/utils.ts

@@ -3,7 +3,7 @@
 //
 
 import { type Mutex, type MutexGuard } from '@dxos/async';
-import { cancelWithContext, type Context, ContextDisposedError } from '@dxos/context';
+import { type Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
 export const stateToString = (state: Invitation.State): string => {

package/src/packlets/locks/browser.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { asyncTimeout, Trigger } from '@dxos/async';
+import { Trigger, asyncTimeout } from '@dxos/async';
 import { RESOURCE_LOCK_TIMEOUT } from '@dxos/client-protocol';
 import { log, logInfo } from '@dxos/log';
 

package/src/packlets/locks/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './resource-lock';
-export * from './node';
+export type * from './resource-lock';
+export * from '#locks-platform';

package/src/packlets/logging/logging-service.ts

@@ -5,27 +5,25 @@
 import { Event } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf/stream';
 import { PublicKey } from '@dxos/keys';
+import { type LogLevel, type LogProcessor, type LogEntry as NaturalLogEntry, log } from '@dxos/log';
 import {
-  type LogLevel,
-  type LogProcessor,
-  type LogEntry as NaturalLogEntry,
-  getContextFromEntry,
-  log,
-} from '@dxos/log';
-import {
+  type ControlMetricsRequest,
+  type ControlMetricsResponse,
   type LogEntry,
   type LoggingService,
   type Metrics,
   QueryLogsRequest,
-  type ControlMetricsRequest,
-  type ControlMetricsResponse,
   type QueryMetricsRequest,
   type QueryMetricsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
-import { getDebugName, jsonify, numericalValues, tracer } from '@dxos/util';
+import { numericalValues, tracer } from '@dxos/util';
 
 /**
  * Logging service used to spy on logs of the host.
+ *
+ * @deprecated This was created so that logs from the shared worker (WorkerClientServices) could be
+ * seen in the main window console without opening the shared worker DevTools. Shared worker client
+ * services is deprecated; dedicated worker logs already show in the main window console.
  */
 export class LoggingServiceImpl implements LoggingService {
   private readonly _logs = new Event<NaturalLogEntry>();
@@ -37,7 +35,7 @@ export class LoggingServiceImpl implements LoggingService {
   }
 
   async close(): Promise<void> {
-    const index = log.runtimeConfig.processors.findIndex((processor) => processor === this._logProcessor);
+    const index = log.runtimeConfig.processors.findIndex((processor: LogProcessor) => processor === this._logProcessor);
     log.runtimeConfig.processors.splice(index, 1);
   }
 
@@ -110,18 +108,25 @@ export class LoggingServiceImpl implements LoggingService {
           return;
         }
 
+        const { filename, line, context: scopeName } = entry.computedMeta;
+        const recordContext: Record<string, any> = { ...entry.computedContext };
+        if (entry.computedError !== undefined) {
+          recordContext.error = entry.computedError;
+        }
+
         const record: LogEntry = {
-          ...entry,
-          context: jsonify(getContextFromEntry(entry)),
-          timestamp: new Date(),
+          level: entry.level,
+          message: entry.message ?? entry.computedError ?? '',
+          context: recordContext,
+          timestamp: new Date(entry.timestamp),
           meta: {
             // TODO(dmaretskyi): Fix proto.
-            file: entry.meta?.F ?? '',
-            line: entry.meta?.L ?? 0,
+            file: filename ?? '',
+            line: line ?? 0,
             scope: {
               hostSessionId: this._sessionId,
               uptimeSeconds: (Date.now() - this._started) / 1000,
-              name: getDebugName(entry.meta?.S),
+              name: scopeName ?? '',
             },
           },
         };

package/src/packlets/logging/logging.test.ts

@@ -5,7 +5,7 @@
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
-import { log, LogLevel } from '@dxos/log';
+import { LogLevel, log } from '@dxos/log';
 import { type LogEntry } from '@dxos/protocols/proto/dxos/client/services';
 
 import { LoggingServiceImpl } from './logging-service';

package/src/packlets/network/network-service.test.ts

@@ -2,15 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
+import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { type NetworkService, ConnectionState } from '@dxos/protocols/proto/dxos/client/services';
+import { ConnectionState, type NetworkService } from '@dxos/protocols/proto/dxos/client/services';
 
-import { NetworkServiceImpl } from './network-service';
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
+import { NetworkServiceImpl } from './network-service';
 
 describe('NetworkService', () => {
   let serviceContext: ServiceContext;

package/src/packlets/network/network-service.ts

@@ -2,20 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
+import { type RequestOptions } from '@dxos/codec-protobuf';
 import { Stream } from '@dxos/codec-protobuf/stream';
+import { Context } from '@dxos/context';
 import { type EdgeConnection } from '@dxos/edge-client';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
 import {
-  type SubscribeSwarmStateRequest,
   type NetworkService,
   type NetworkStatus,
+  type SubscribeSwarmStateRequest,
   type UpdateConfigRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Peer, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import {
-  type LeaveRequest,
   type JoinRequest,
+  type LeaveRequest,
   type Message,
   type QueryRequest,
 } from '@dxos/protocols/proto/dxos/edge/signal';
@@ -47,16 +49,16 @@ export class NetworkServiceImpl implements NetworkService {
     await this.networkManager.setConnectionState(request.swarm);
   }
 
-  async joinSwarm(request: JoinRequest): Promise<void> {
-    return this.signalManager.join(request);
+  async joinSwarm(request: JoinRequest, options?: RequestOptions): Promise<void> {
+    return this.signalManager.join(options?.ctx ?? Context.default(), request);
   }
 
-  async leaveSwarm(request: LeaveRequest): Promise<void> {
-    return this.signalManager.leave(request);
+  async leaveSwarm(request: LeaveRequest, options?: RequestOptions): Promise<void> {
+    return this.signalManager.leave(options?.ctx ?? Context.default(), request);
   }
 
-  async querySwarm(request: QueryRequest): Promise<SwarmResponse> {
-    return this.signalManager.query(request);
+  async querySwarm(request: QueryRequest, options?: RequestOptions): Promise<SwarmResponse> {
+    return this.signalManager.query(options?.ctx ?? Context.default(), request);
   }
 
   subscribeSwarmState(request: SubscribeSwarmStateRequest): Stream<SwarmResponse> {
@@ -69,8 +71,8 @@ export class NetworkServiceImpl implements NetworkService {
     });
   }
 
-  async sendMessage(message: Message): Promise<void> {
-    return this.signalManager.sendMessage(message);
+  async sendMessage(message: Message, options?: RequestOptions): Promise<void> {
+    return this.signalManager.sendMessage(options?.ctx ?? Context.default(), message);
   }
 
   subscribeMessages(peer: Peer): Stream<Message> {

package/src/packlets/services/client-rpc-server.ts

@@ -3,25 +3,27 @@
 //
 
 import { type ClientServices } from '@dxos/client-protocol';
-import { type Any, type ServiceHandler, Stream } from '@dxos/codec-protobuf';
+import { type Any, type RequestOptions, type ServiceHandler, Stream } from '@dxos/codec-protobuf';
 import { raise } from '@dxos/debug';
-import { parseMethodName, RpcPeer, type RpcPeerOptions, type ServiceBundle } from '@dxos/rpc';
+import { RpcPeer, type RpcPeerOptions, type ServiceBundle, parseMethodName } from '@dxos/rpc';
 import { MapCounter, trace } from '@dxos/tracing';
 import { type MaybePromise } from '@dxos/util';
 
 import { type ServiceRegistry } from './service-registry';
 
-export type ClientRpcServerParams = {
+export type ClientRpcServerProps = {
   serviceRegistry: ServiceRegistry<ClientServices>;
   handleCall?: (
     method: string,
     params: Any,
-    handler: (method: string, params: Any) => MaybePromise<Any>,
+    handler: (method: string, params: Any, options?: RequestOptions) => MaybePromise<Any>,
+    options?: RequestOptions,
   ) => Promise<Any>;
   handleStream?: (
     method: string,
     params: Any,
-    handler: (method: string, params: Any) => Stream<Any>,
+    handler: (method: string, params: Any, options?: RequestOptions) => Stream<Any>,
+    options?: RequestOptions,
   ) => MaybePromise<Stream<Any>>;
 } & Omit<RpcPeerOptions, 'callHandler' | 'streamHandler'>;
 
@@ -30,8 +32,8 @@ export class ClientRpcServer {
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
   private readonly _rpcPeer: RpcPeer;
   private readonly _handlerCache = new Map<string, ServiceHandler<any>>();
-  private readonly _handleCall: ClientRpcServerParams['handleCall'];
-  private readonly _handleStream: ClientRpcServerParams['handleStream'];
+  private readonly _handleCall: ClientRpcServerProps['handleCall'];
+  private readonly _handleStream: ClientRpcServerProps['handleStream'];
 
   @trace.metricsCounter()
   private readonly _callMetrics = new MapCounter();
@@ -41,7 +43,7 @@ export class ClientRpcServer {
     return Object.keys(this._serviceRegistry.services);
   }
 
-  constructor(params: ClientRpcServerParams) {
+  constructor(params: ClientRpcServerProps) {
     const { serviceRegistry, handleCall, handleStream, ...rpcOptions } = params;
     this._handleCall = handleCall;
     this._handleStream = handleStream;
@@ -49,32 +51,33 @@ export class ClientRpcServer {
     this._serviceRegistry = serviceRegistry;
     this._rpcPeer = new RpcPeer({
       ...rpcOptions,
-      callHandler: (method, params) => {
+      callHandler: (method, params, options) => {
         const [serviceName, methodName] = parseMethodName(method);
-        const handler = (method: string, params: Any) => this._getServiceHandler(serviceName).call(method, params);
+        const handler = (method: string, params: Any, handlerOptions?: RequestOptions) =>
+          this._getServiceHandler(serviceName).call(method, params, handlerOptions);
 
         this._callMetrics.inc(`${serviceName}.${methodName} request`);
 
         if (this._handleCall) {
-          return this._handleCall(methodName, params, handler);
+          return this._handleCall(methodName, params, handler, options);
         } else {
-          return handler(methodName, params);
+          return handler(methodName, params, options);
         }
       },
-      streamHandler: (method, params) => {
+      streamHandler: (method, params, options) => {
         const [serviceName, methodName] = parseMethodName(method);
-        const handler = (method: string, params: Any) =>
-          this._getServiceHandler(serviceName).callStream(method, params);
+        const handler = (method: string, params: Any, handlerOptions?: RequestOptions) =>
+          this._getServiceHandler(serviceName).callStream(method, params, handlerOptions);
 
         this._callMetrics.inc(`${serviceName}.${methodName} request stream`);
 
         if (this._handleStream) {
-          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params, handler)), (data) => {
+          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params, handler, options)), (data) => {
             this._callMetrics.inc(`${serviceName}.${methodName} response stream`);
             return data;
           });
         } else {
-          return handler(methodName, params);
+          return handler(methodName, params, options);
         }
       },
     });