@livestore/webmesh 0.3.0-dev.4 → 0.3.0-dev.40

package/src/common.ts

@@ -1,6 +1,6 @@
-import { type Effect, Schema } from '@livestore/utils/effect'
+import { type Effect, Predicate, Schema } from '@livestore/utils/effect'
 
-import type { MessageChannelPacket, Packet, ProxyChannelPacket } from './mesh-schema.js'
+import type { DirectChannelPacket, Packet, ProxyChannelPacket } from './mesh-schema.js'
 
 export type ProxyQueueItem = {
   packet: typeof ProxyChannelPacket.Type
@@ -8,29 +8,36 @@ export type ProxyQueueItem = {
 }
 
 export type MessageQueueItem = {
-  packet: typeof MessageChannelPacket.Type
-  respondToSender: (msg: typeof MessageChannelPacket.Type) => Effect.Effect<void>
+  packet: typeof DirectChannelPacket.Type
+  respondToSender: (msg: typeof DirectChannelPacket.Type) => Effect.Effect<void>
 }
 
 export type MeshNodeName = string
 
 export type ChannelName = string
-export type ChannelKey = `${MeshNodeName}-${ChannelName}`
+export type ChannelKey = `target:${MeshNodeName}, channelName:${ChannelName}`
 
 // TODO actually use this to avoid timeouts in certain cases
-export class NoConnectionRouteSignal extends Schema.TaggedError<NoConnectionRouteSignal>()(
-  'NoConnectionRouteSignal',
-  {},
-) {}
-
-export class ConnectionAlreadyExistsError extends Schema.TaggedError<ConnectionAlreadyExistsError>()(
-  'ConnectionAlreadyExistsError',
-  {
-    target: Schema.String,
-  },
-) {}
+// export class NoConnectionRouteSignal extends Schema.TaggedError<NoConnectionRouteSignal>()(
+//   'NoConnectionRouteSignal',
+//   {},
+// ) {}
+
+export class EdgeAlreadyExistsError extends Schema.TaggedError<EdgeAlreadyExistsError>()('EdgeAlreadyExistsError', {
+  target: Schema.String,
+}) {}
 
 export const packetAsOtelAttributes = (packet: typeof Packet.Type) => ({
   packetId: packet.id,
-  ...(packet._tag !== 'MessageChannelResponseSuccess' && packet._tag !== 'ProxyChannelPayload' ? { packet } : {}),
+  'span.label':
+    packet.id + (Predicate.hasProperty(packet, 'reqId') && packet.reqId !== undefined ? ` for ${packet.reqId}` : ''),
+  ...(packet._tag !== 'DirectChannelResponseSuccess' && packet._tag !== 'ProxyChannelPayload' ? { packet } : {}),
+})
+
+export const ListenForChannelResult = Schema.Struct({
+  channelName: Schema.String,
+  source: Schema.String,
+  mode: Schema.Union(Schema.Literal('proxy'), Schema.Literal('direct')),
 })
+
+export type ListenForChannelResult = typeof ListenForChannelResult.Type

package/src/mesh-schema.ts

@@ -16,28 +16,40 @@ const defaultPacketFields = {
 
 const remainingHopsUndefined = Schema.Undefined.pipe(Schema.optional)
 
-// Needs to go through already existing MessageChannel connections, times out otherwise
-export class MessageChannelRequest extends Schema.TaggedStruct('MessageChannelRequest', {
+/**
+ * Needs to go through already existing DirectChannel edges, times out otherwise
+ *
+ * Can't yet contain the `port` because the request might be duplicated while forwarding to multiple nodes.
+ * We need a clear path back to the sender to avoid this, thus we respond with a separate
+ * `DirectChannelResponseSuccess` which contains the `port`.
+ */
+export class DirectChannelRequest extends Schema.TaggedStruct('DirectChannelRequest', {
   ...defaultPacketFields,
-  remainingHops: remainingHopsUndefined,
+  remainingHops: Schema.Array(Schema.String).pipe(Schema.optional),
+  channelVersion: Schema.Number,
+  /** Only set if the request is in response to an incoming request */
+  reqId: Schema.UndefinedOr(Schema.String),
+  /**
+   * Additionally to the `source` field, we use this field to track whether the instance of a
+   * source has changed.
+   */
+  sourceId: Schema.String,
 }) {}
 
-export class MessageChannelResponseSuccess extends Schema.TaggedStruct('MessageChannelResponseSuccess', {
+export class DirectChannelResponseSuccess extends Schema.TaggedStruct('DirectChannelResponseSuccess', {
   ...defaultPacketFields,
   reqId: Schema.String,
   port: Transferable.MessagePort,
   // Since we can't copy this message, we need to follow the exact route back to the sender
   remainingHops: Schema.Array(Schema.String),
+  channelVersion: Schema.Number,
 }) {}
 
-export class MessageChannelResponseNoTransferables extends Schema.TaggedStruct(
-  'MessageChannelResponseNoTransferables',
-  {
-    ...defaultPacketFields,
-    reqId: Schema.String,
-    remainingHops: Schema.Array(Schema.String),
-  },
-) {}
+export class DirectChannelResponseNoTransferables extends Schema.TaggedStruct('DirectChannelResponseNoTransferables', {
+  ...defaultPacketFields,
+  reqId: Schema.String,
+  remainingHops: Schema.Array(Schema.String),
+}) {}
 
 export class ProxyChannelRequest extends Schema.TaggedStruct('ProxyChannelRequest', {
   ...defaultPacketFields,
@@ -68,20 +80,51 @@ export class ProxyChannelPayloadAck extends Schema.TaggedStruct('ProxyChannelPay
 }) {}
 
 /**
- * Broadcast to all nodes when a new connection is added.
+ * Broadcast to all nodes when a new edge is added.
  * Mostly used for auto-reconnect purposes.
  */
-// TODO actually use for this use case
-export class NetworkConnectionAdded extends Schema.TaggedStruct('NetworkConnectionAdded', {
+export class NetworkEdgeAdded extends Schema.TaggedStruct('NetworkEdgeAdded', {
   id,
   source: Schema.String,
   target: Schema.String,
 }) {}
 
-export class MessageChannelPacket extends Schema.Union(
-  MessageChannelRequest,
-  MessageChannelResponseSuccess,
-  MessageChannelResponseNoTransferables,
+export class NetworkTopologyRequest extends Schema.TaggedStruct('NetworkTopologyRequest', {
+  id,
+  hops: Schema.Array(Schema.String),
+  /** Always fixed to who requested the topology */
+  source: Schema.String,
+  target: Schema.Literal('-'),
+}) {}
+
+export class NetworkTopologyResponse extends Schema.TaggedStruct('NetworkTopologyResponse', {
+  id,
+  reqId: Schema.String,
+  remainingHops: Schema.Array(Schema.String),
+  nodeName: Schema.String,
+  edges: Schema.Array(Schema.String),
+  /** Always fixed to who requested the topology */
+  source: Schema.String,
+  target: Schema.Literal('-'),
+}) {}
+
+export const BroadcastChannelPacket = Schema.TaggedStruct('BroadcastChannelPacket', {
+  id,
+  channelName: Schema.String,
+  /**
+   * The payload is expected to be encoded/decoded by the send/listen schema.
+   * Transferables are not supported.
+   */
+  payload: Schema.Any,
+  hops: Schema.Array(Schema.String),
+  source: Schema.String,
+  target: Schema.Literal('-'),
+})
+
+export class DirectChannelPacket extends Schema.Union(
+  DirectChannelRequest,
+  DirectChannelResponseSuccess,
+  DirectChannelResponseNoTransferables,
 ) {}
 
 export class ProxyChannelPacket extends Schema.Union(
@@ -91,4 +134,14 @@ export class ProxyChannelPacket extends Schema.Union(
   ProxyChannelPayloadAck,
 ) {}
 
-export class Packet extends Schema.Union(MessageChannelPacket, ProxyChannelPacket, NetworkConnectionAdded) {}
+export class Packet extends Schema.Union(
+  DirectChannelPacket,
+  ProxyChannelPacket,
+  NetworkEdgeAdded,
+  NetworkTopologyRequest,
+  NetworkTopologyResponse,
+  BroadcastChannelPacket,
+) {}
+
+export class DirectChannelPing extends Schema.TaggedStruct('DirectChannelPing', {}) {}
+export class DirectChannelPong extends Schema.TaggedStruct('DirectChannelPong', {}) {}

package/src/mod.ts

@@ -1,4 +1,4 @@
-export * from './websocket-connection.js'
+export * from './websocket-edge.js'
 export * from './node.js'
 export * as WebmeshSchema from './mesh-schema.js'
-export { ConnectionAlreadyExistsError } from './common.js'
+export { EdgeAlreadyExistsError } from './common.js'