@dxos/protocols 0.8.4-main.406dc2a → 0.8.4-main.40e3dcdf1b

package/src/edge/errors.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EdgeErrorData, type EdgeFailure, EdgeHttpErrorCodec, ErrorCodec } from './edge.ts';
+
+// TODO(burdon): Reconcile with @dxos/errors.
+/**
+ * Error thrown when a call to the Edge service fails.
+ * There 3 possible sources of failure:
+ * 1. EdgeFailure (JSON body with { success: false }) -> Processing the request failed and was gracefully handled by EDGE service.
+ * 2. Http failure (non-ok code) -> The HTTP request failed (e.g. timeout, network error).
+ *                               -> Unhandled exception on EDGE side, EDGE would provide serialized error in the response body.
+ * 3. Processing failure -> Unhandled exception on client side while processing the response.
+ */
+export class EdgeCallFailedError extends Error {
+  public static fromUnsuccessfulResponse(response: Response, body: EdgeFailure): EdgeCallFailedError {
+    const error = new EdgeCallFailedError({
+      message: body.message,
+      data: body.data,
+      isRetryable: body.data == null && response.headers.has('Retry-After'),
+      retryAfterMs: getRetryAfterMillis(response),
+      cause: body.error ? ErrorCodec.decode(body.error) : undefined,
+    });
+
+    return error;
+  }
+
+  public static async fromHttpFailure(response: Response): Promise<EdgeCallFailedError> {
+    return new EdgeCallFailedError({
+      message: `HTTP code ${response.status}: ${response.statusText}.`,
+      isRetryable: isRetryableCode(response.status),
+      retryAfterMs: getRetryAfterMillis(response),
+      cause: await EdgeHttpErrorCodec.decode(response),
+    });
+  }
+
+  public static fromProcessingFailureCause(cause: Error): EdgeCallFailedError {
+    return new EdgeCallFailedError({
+      message: 'Error processing request.',
+      isRetryable: true,
+      cause,
+    });
+  }
+
+  readonly data?: EdgeErrorData;
+  readonly isRetryable?: boolean;
+  readonly retryAfterMs?: number;
+
+  constructor(args: {
+    message: string;
+    isRetryable?: boolean;
+    data?: EdgeErrorData;
+    retryAfterMs?: number;
+    cause?: Error;
+  }) {
+    super(args.message, { cause: args.cause });
+    this.message = args.message;
+    this.data = args.data;
+    this.retryAfterMs = args.retryAfterMs;
+    this.isRetryable = Boolean(args.isRetryable);
+  }
+}
+
+export class EdgeAuthChallengeError extends EdgeCallFailedError {
+  constructor(
+    public readonly challenge: string,
+    data: EdgeErrorData,
+  ) {
+    super({ message: 'Auth challenge.', data, isRetryable: false });
+  }
+}
+
+const getRetryAfterMillis = (response: Response) => {
+  const retryAfter = Number(response.headers.get('Retry-After'));
+  return Number.isNaN(retryAfter) || retryAfter === 0 ? undefined : retryAfter * 1000;
+};
+
+const isRetryableCode = (status: number) => {
+  if (status === 501) {
+    // Not Implemented
+    return false;
+  }
+  return !(status >= 400 && status < 500);
+};

package/src/edge/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './edge.ts';
+export * as EdgeFunctionEnv from './EdgeFunctionEnv.ts';
+export * from './errors.ts';

package/src/errors/base-errors.ts

@@ -2,43 +2,25 @@
 // Copyright 2021 DXOS.org
 //
 
-// TODO(dmaretskyi): Reconcile with @dxos/errors
-
 /**
  * NOTE: Messages should be sentences (Start with a capital letter and end with a period).
  * Errors can optionally include a JSON context object.
  */
-export class BaseError extends Error {
-  constructor(
-    readonly code: string,
-    message?: string,
-    readonly context?: Record<string, any>,
-  ) {
-    // TODO(dmaretskyi): Error.cause.
-    super(message ?? code);
-    this.name = code;
-    // NOTE: Restores prototype chain (https://stackoverflow.com/a/48342359).
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-
-// TODO(dmaretskyi): Consider common error classes with error codes:
-// throw new SystemError(ERROR_CODE_OUT_OF_MEMORY, 'Out of memory', { a: 1, b: 2 });
+import { BaseError } from '@dxos/errors';
 
 /**
  * User facing API Errors.
  * E.g., something was misconfigured.
  */
-export class ApiError extends BaseError {}
+export class ApiError extends BaseError.extend('ApiError') {}
 
 /**
  * Internal system errors.
  * E.g., unexpected/unrecoverable runtime error.
  */
-export class SystemError extends BaseError {}
+export class SystemError extends BaseError.extend('SystemError') {}
 
 /**
  * Database errors.
  */
-// TODO(wittjosiah): Same as ApiError?
-export class DatabaseError extends BaseError {}
+export class DatabaseError extends BaseError.extend('DatabaseError') {}

package/src/errors/encoding.ts

@@ -2,9 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.js';
+import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.ts';
 
-import { reconstructError } from './helpers.js';
+import { reconstructError } from './helpers.ts';
 
 export const encodeError = (err: any): SerializedErrorProto => {
   if (typeof err === 'object' && err?.message) {

package/src/errors/errors.test.ts

@@ -4,12 +4,12 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { ApiError } from './base-errors.js';
+import { ApiError } from './base-errors.ts';
 
 describe('Errors', () => {
   test('test', async () => {
     const runTest = async () => {
-      throw new ApiError('Test error');
+      throw new ApiError({ message: 'Test error' });
     };
 
     await expect(runTest()).rejects.toThrowError('Test error');

package/src/errors/errors.ts

@@ -2,208 +2,142 @@
 // Copyright 2021 DXOS.org
 //
 
+import { BaseError } from '@dxos/errors';
 import { PublicKey } from '@dxos/keys';
 
-import type { ObjectId } from '../types.js';
+import type { ObjectId } from '../types.ts';
 
-import { ApiError, BaseError, DatabaseError, SystemError } from './base-errors.js';
-import { registerError, registerErrorMessageContext, registerErrorNoArgs } from './helpers.js';
+import { registerError, registerErrorMessageContext, registerErrorNoArgs } from './helpers.ts';
 
 /**
  * Thrown when request was terminated because the RPC endpoint has been closed.
  */
-export class RpcClosedError extends SystemError {
-  constructor() {
-    super('RPC_CLOSED', 'Request was terminated because the RPC endpoint is closed.');
-  }
-}
+export class RpcClosedError extends BaseError.extend(
+  'RpcClosedError',
+  'Request was terminated because the RPC endpoint is closed.',
+) {}
 
-registerErrorNoArgs('RPC_CLOSED', RpcClosedError);
+registerErrorNoArgs('RpcClosedError', RpcClosedError);
 
 /**
  * Thrown when `request` is called when RPC has not been opened.
  */
-export class RpcNotOpenError extends SystemError {
-  constructor() {
-    super('RPC_NOT_OPEN', 'RPC has not been opened.');
-  }
-}
+export class RpcNotOpenError extends BaseError.extend('RpcNotOpenError', 'RPC has not been opened.') {}
 
-registerErrorNoArgs('RPC_NOT_OPEN', RpcNotOpenError);
+registerErrorNoArgs('RpcNotOpenError', RpcNotOpenError);
 
-export class CancelledError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('CANCELLED', message, context);
-  }
-}
+export class CancelledError extends BaseError.extend('CancelledError') {}
 
-registerErrorMessageContext('CANCELLED', CancelledError);
+registerErrorMessageContext('CancelledError', CancelledError);
 
-export class InvalidConfigError extends ApiError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_CONFIG', message, context);
-  }
-}
+export class InvalidConfigError extends BaseError.extend('InvalidConfigError') {}
 
-registerErrorMessageContext('INVALID_CONFIG', InvalidConfigError);
+registerErrorMessageContext('InvalidConfigError', InvalidConfigError);
 
 /**
  * Explicit failure to connect with remote client services.
  */
-export class RemoteServiceConnectionError extends ApiError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('REMOTE_SERVICE_CONNECTION_ERROR', message, context);
-  }
-}
+export class RemoteServiceConnectionError extends BaseError.extend('RemoteServiceConnectionError') {}
 
-registerErrorMessageContext('REMOTE_SERVICE_CONNECTION_ERROR', RemoteServiceConnectionError);
+registerErrorMessageContext('RemoteServiceConnectionError', RemoteServiceConnectionError);
 
 /**
  * Failed to open a connection to remote client services.
  */
-export class RemoteServiceConnectionTimeout extends ApiError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('REMOTE_SERVICE_CONNECTION_TIMEOUT', message, context);
-  }
-}
+export class RemoteServiceConnectionTimeout extends BaseError.extend('RemoteServiceConnectionTimeout') {}
 
-registerErrorMessageContext('REMOTE_SERVICE_CONNECTION_TIMEOUT', RemoteServiceConnectionTimeout);
+registerErrorMessageContext('RemoteServiceConnectionTimeout', RemoteServiceConnectionTimeout);
 
-export class DataCorruptionError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('DATA_CORRUPTION', message, context);
-  }
-}
+export class DataCorruptionError extends BaseError.extend('DataCorruptionError') {}
 
-registerErrorMessageContext('DATA_CORRUPTION', DataCorruptionError);
+registerErrorMessageContext('DataCorruptionError', DataCorruptionError);
 
-export class InvalidInvitationExtensionRoleError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_INVITATION_EXTENSION_ROLE', message, context);
-  }
-}
+export class InvalidInvitationExtensionRoleError extends BaseError.extend('InvalidInvitationExtensionRoleError') {}
 
-registerErrorMessageContext('INVALID_INVITATION_EXTENSION_ROLE', InvalidInvitationExtensionRoleError);
+registerErrorMessageContext('InvalidInvitationExtensionRoleError', InvalidInvitationExtensionRoleError);
 
-export class IdentityNotInitializedError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('IDENTITY_NOT_INITIALIZED', message, context);
-  }
-}
+export class IdentityNotInitializedError extends BaseError.extend('IdentityNotInitializedError') {}
 
-registerErrorMessageContext('IDENTITY_NOT_INITIALIZED', IdentityNotInitializedError);
+registerErrorMessageContext('IdentityNotInitializedError', IdentityNotInitializedError);
 
-export class InvalidInvitationError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_INVITATION', message, context);
-  }
-}
+export class InvalidInvitationError extends BaseError.extend('InvalidInvitationError') {}
 
-registerErrorMessageContext('INVALID_INVITATION', InvalidInvitationError);
+registerErrorMessageContext('InvalidInvitationError', InvalidInvitationError);
 
-export class AlreadyJoinedError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('ALREADY_JOINED', message, context);
-  }
-}
+export class AlreadyJoinedError extends BaseError.extend('AlreadyJoinedError') {}
 
-registerErrorMessageContext('ALREADY_JOINED', AlreadyJoinedError);
+registerErrorMessageContext('AlreadyJoinedError', AlreadyJoinedError);
 
-export class ConnectionResetError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('CONNECTION_RESET', message, context);
-  }
-}
+export class ConnectionResetError extends BaseError.extend('ConnectionResetError') {}
 
-registerErrorMessageContext('CONNECTION_RESET', ConnectionResetError);
+registerErrorMessageContext('ConnectionResetError', ConnectionResetError);
 
-export class TimeoutError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('TIMEOUT', message, context);
-  }
-}
+export class TimeoutError extends BaseError.extend('TimeoutError') {}
 
-registerErrorMessageContext('TIMEOUT', TimeoutError);
+registerErrorMessageContext('TimeoutError', TimeoutError);
 
 // General protocol error.
-export class ProtocolError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('PROTOCOL_ERROR', message, context);
-  }
-}
+export class ProtocolError extends BaseError.extend('ProtocolError') {}
 
-registerErrorMessageContext('PROTOCOL_ERROR', ProtocolError);
+registerErrorMessageContext(ProtocolError.name, ProtocolError);
 
 // General connectivity errors.
-export class ConnectivityError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('CONNECTIVITY_ERROR', message, context);
-  }
-}
+export class ConnectivityError extends BaseError.extend('ConnectivityError') {}
 
-registerErrorMessageContext('CONNECTIVITY_ERROR', ConnectivityError);
+registerErrorMessageContext('ConnectivityError', ConnectivityError);
 
-export class RateLimitExceededError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('RATE_LIMIT_EXCEEDED', message, context);
-  }
-}
+export class RateLimitExceededError extends BaseError.extend('RateLimitExceededError') {}
 
-registerErrorMessageContext('RATE_LIMIT_EXCEEDED', RateLimitExceededError);
+registerErrorMessageContext('RateLimitExceededError', RateLimitExceededError);
 
 // TODO(nf): Rename? the protocol isn't what's unknown...
-export class UnknownProtocolError extends BaseError {
-  constructor(message?: string, innerError?: Error) {
-    super('UNKNOWN_PROTOCOL_ERROR', message, innerError);
-  }
-}
+export class UnknownProtocolError extends BaseError.extend('UnknownProtocolError') {}
 
-registerErrorMessageContext('UNKNOWN_PROTOCOL_ERROR', UnknownProtocolError);
+registerError(UnknownProtocolError.name, (message, context) => new UnknownProtocolError({ message, context }));
 
-export class InvalidStorageVersionError extends DatabaseError {
+export class InvalidStorageVersionError extends BaseError.extend(
+  'InvalidStorageVersionError',
+  'Invalid storage version.',
+) {
   constructor(expected: number, actual: number) {
-    super('INVALID_STORAGE_VERSION', 'Invalid storage version.', { expected, actual });
+    super({ context: { expected, actual } });
   }
 }
 
-registerError('INVALID_STORAGE_VERSION', (_, context) => {
+registerError('InvalidStorageVersionError', (_, context) => {
   return new InvalidStorageVersionError(context.expected ?? NaN, context.actual ?? NaN);
 });
 
-export class SpaceNotFoundError extends DatabaseError {
+export class SpaceNotFoundError extends BaseError.extend('SpaceNotFoundError', 'Space not found.') {
   constructor(spaceKey: PublicKey) {
-    super('SPACE_NOT_FOUND', 'Space not found.', { spaceKey });
+    super({ context: { spaceKey } });
   }
 }
 
-registerError('SPACE_NOT_FOUND', (_, context) => {
+registerError('SpaceNotFoundError', (_, context) => {
   return new SpaceNotFoundError(PublicKey.safeFrom(context.spaceKey) ?? PublicKey.from('00'));
 });
 
-export class EntityNotFoundError extends DatabaseError {
+export class EntityNotFoundError extends BaseError.extend('EntityNotFoundError', 'Item not found.') {
   constructor(entityId: ObjectId) {
-    super('ITEM_NOT_FOUND', 'Item not found.', { entityId });
+    super({ context: { entityId } });
   }
 }
 
-registerError('ITEM_NOT_FOUND', (_, context) => {
+registerError('EntityNotFoundError', (_, context) => {
   return new EntityNotFoundError(context.entityId);
 });
 
-export class UnknownModelError extends DatabaseError {
+export class UnknownModelError extends BaseError.extend('UnknownModelError', 'Unknown model.') {
   constructor(model: string) {
-    super('UNKNOWN_MODEL', 'Unknown model.', { model });
+    super({ context: { model } });
   }
 }
 
-registerError('UNKNOWN_MODEL', (_, context) => {
+registerError('UnknownModelError', (_, context) => {
   return new UnknownModelError(context.model);
 });
 
-export class AuthorizationError extends ApiError {
-  constructor(message?: string, context?: any) {
-    super('AUTHORIZATION_ERROR', message, context);
-  }
-}
+export class AuthorizationError extends BaseError.extend('AuthorizationError') {}
 
-registerErrorMessageContext('AUTHORIZATION_ERROR', AuthorizationError);
+registerErrorMessageContext('AuthorizationError', AuthorizationError);

package/src/errors/helpers.ts

@@ -2,11 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
+import { BaseError } from '@dxos/errors';
 import { invariant } from '@dxos/invariant';
 
-import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.js';
-
-import { SystemError } from './base-errors.js';
+import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.ts';
 
 export const reconstructError = (error: SerializedErrorProto) => {
   const { name, message, context } = error;
@@ -20,21 +19,21 @@ export const registerError = (code: string, make: (message?: string, context?: a
   errorRegistry.set(code, make);
 };
 
-export const registerErrorNoArgs = (code: string, Constructor: { new (): Error }) => {
+export const registerErrorNoArgs = (code: string, Constructor: { new (options?: any): Error }) => {
   registerError(code, () => new Constructor());
 };
 
 export const registerErrorMessageContext = (
   code: string,
-  Constructor: { new (message?: string, context?: any): Error },
+  Constructor: { new (options?: { message?: string; context?: any }): Error },
 ) => {
-  registerError(code, (message?: string, context?: string) => new Constructor(message, context));
+  registerError(code, (message?: string, context?: any) => new Constructor({ message, context }));
 };
 
 export const errorFromCode = (code?: string, message?: string, context?: any) => {
   if (code && errorRegistry.has(code)) {
     return errorRegistry.get(code)!(message, context);
   } else {
-    return new SystemError(code ?? 'Error', message, context);
+    return new BaseError(code ?? 'Error', { message, context });
   }
 };

package/src/errors/index.ts

@@ -2,8 +2,8 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './encoding.js';
-export * from './errors.js';
-export * from './helpers.js';
-export * from './base-errors.js';
-export * from './parameter.js';
+export * from './encoding.ts';
+export * from './errors.ts';
+export * from './helpers.ts';
+export * from './base-errors.ts';
+export * from './parameter.ts';

package/src/feed-replication.ts

@@ -12,6 +12,7 @@ export type FeedBlock = {
   }[];
   signature: Uint8Array;
 };
+
 export type GetMetadataProtocolMessage = {
   type: 'get-metadata';
   feedKey: string;

package/src/index.ts

@@ -2,15 +2,15 @@
 // Copyright 2021 DXOS.org
 //
 
-export * from './automerge.js';
-export * from './edge-error.js';
-export * from './edge.js';
-export * from './errors/index.js';
-export * from './indexing.js';
-export * from './profile-archive.js';
-export * from './query.js';
-export * from './queue.js';
-export * from './space-archive.js';
-export * from './storage.js';
-export * from './tracing.js';
-export type * from './types.js';
+export * from './automerge.ts';
+export * from './edge/index.ts';
+export * from './errors/index.ts';
+export * from './indexing.ts';
+export * from './messenger.ts';
+export * from './profile-archive.ts';
+export * from './space-archive.ts';
+export * from './storage.ts';
+export * from './tracing.ts';
+export type * from './types.ts';
+export * as FunctionProtocol from './FunctionProtocol.ts';
+export * as FeedProtocol from './FeedProtocol.ts';

package/src/indexing.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { ObjectPointerVersion, objectPointerCodec } from './indexing.js';
+import { ObjectPointerVersion, objectPointerCodec } from './indexing.ts';
 
 describe('Indexing object pointer codec', () => {
   test('getVersion', async () => {

package/src/messenger.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type CleanupFn } from '@dxos/async';
+
+import { type GossipMessage } from './proto/gen/dxos/mesh/teleport/gossip';
+
+/**
+ * Message passing abstraction.
+ */
+export interface Messenger {
+  /**
+   * Register channel listener.
+   */
+  listen: (channel: string, callback: (message: GossipMessage) => void) => CleanupFn;
+
+  /**
+   * Send message to channel.
+   */
+  postMessage: (channel: string, message: any) => Promise<void>;
+}

package/src/proto/dxos/client/queue.proto

@@ -0,0 +1,78 @@
+syntax = "proto3";
+
+package dxos.client.services;
+
+import "google/protobuf/struct.proto";
+import "google/protobuf/empty.proto";
+
+
+message QueueQuery {
+  string space_id = 1;
+
+  optional string queues_namespace = 2;
+
+  /// Queries the whole space if missing.
+  repeated string queue_ids = 3;
+
+  /// Filter items after this cursor. Exclusive.
+  optional string after = 4;
+
+  /// Filter items before this cursor. Exclusive.
+  optional string before = 5;
+
+  /// Filter items after this position. Inclusive.
+  optional int64 begin_position = 6;
+
+  /// Filter items before this position. Exclusive.
+  optional int64 end_position = 7;
+
+  optional int32 limit = 8;
+  optional bool reverse = 9;
+
+  // TODO(dmaretskyi): Remove this field -- raw queues dont index object IDs anymore.
+  repeated string object_ids = 100;
+}
+
+message QueueQueryResult {
+  repeated google.protobuf.Struct objects = 1;
+
+  /// Cursor to query the next items. Can be passed to `after` in query to keep querying. 
+  string next_cursor = 2;
+
+  string prev_cursor = 3;
+}
+
+message QueryQueueRequest {
+  QueueQuery query = 1;
+}
+
+message InsertIntoQueueRequest {
+  string subspace_tag = 1;
+  string space_id = 2;
+  string queue_id = 3;
+  repeated google.protobuf.Struct objects = 4;
+}
+
+message DeleteFromQueueRequest {
+  string subspace_tag = 1;
+  string space_id = 2;
+  string queue_id = 3;
+  repeated string object_ids = 4;
+}
+
+message SyncQueueRequest {
+  string subspace_tag = 1;
+  string space_id = 2;
+  string queue_id = 3;
+  /// Whether to push local changes to the server. Defaults to true.
+  optional bool should_push = 4;
+  /// Whether to pull remote changes from the server. Defaults to true.
+  optional bool should_pull = 5;
+}
+
+service QueueService {
+  rpc QueryQueue(QueryQueueRequest) returns (QueueQueryResult);
+  rpc InsertIntoQueue(InsertIntoQueueRequest) returns (google.protobuf.Empty);
+  rpc DeleteFromQueue(DeleteFromQueueRequest) returns (google.protobuf.Empty);
+  rpc SyncQueue(SyncQueueRequest) returns (google.protobuf.Empty);
+}

package/src/proto/dxos/client/services.proto

@@ -72,6 +72,7 @@ message Platform {
     BROWSER = 0;
     SHARED_WORKER = 1;
     NODE = 2;
+    DEDICATED_WORKER = 3;
   }
 
   PLATFORM_TYPE type = 1;

package/src/proto/dxos/config.proto

@@ -59,7 +59,7 @@ message Module {
   optional string id = 8;   // TODO(burdon): Ensured FQ (e.g., 'dxos.app.xxx')
   optional string name = 1; // TODO(burdon): Replace with id (or key?)
   optional string type = 2; // TODO(burdon): Define namespace (e.g.,
-                            // 'dxos.org/type/frame' vs. 'dxos.type.frame')
+                            // 'org.dxos.type.frame')
 
   // TODO(burdon): Developer info message.