@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/broadcasting/index.js

@@ -0,0 +1,907 @@
+// src/broadcasting/channels/Channel.ts
+var Channel = class {
+  constructor(name, driver) {
+    this.name = name;
+    this.driver = driver;
+  }
+  /**
+   * Broadcast an event to this channel.
+   */
+  async broadcast(event, data) {
+    await this.driver.publish(this.name, event, data);
+  }
+  /**
+   * Subscribe to events on this channel.
+   * Returns an unsubscribe function.
+   */
+  subscribe(callback) {
+    return this.driver.subscribe(this.name, (e) => {
+      callback(e.event, e.data);
+    });
+  }
+  /**
+   * Get the full channel name for broadcasting.
+   */
+  getChannelName() {
+    return this.name;
+  }
+};
+
+// src/broadcasting/channels/PrivateChannel.ts
+var PrivateChannel = class _PrivateChannel extends Channel {
+  /**
+   * Channel name prefix.
+   */
+  static PREFIX = "private-";
+  constructor(name, driver) {
+    const channelName = name.startsWith(_PrivateChannel.PREFIX) ? name : `${_PrivateChannel.PREFIX}${name}`;
+    super(channelName, driver);
+  }
+  /**
+   * Get the channel name without the private prefix.
+   */
+  getBaseName() {
+    return this.name.startsWith(_PrivateChannel.PREFIX) ? this.name.slice(_PrivateChannel.PREFIX.length) : this.name;
+  }
+  /**
+   * Check if a channel name is a private channel.
+   */
+  static isPrivateChannel(name) {
+    return name.startsWith(_PrivateChannel.PREFIX);
+  }
+  /**
+   * Normalize a channel name to include the private prefix.
+   */
+  static normalize(name) {
+    return name.startsWith(_PrivateChannel.PREFIX) ? name : `${_PrivateChannel.PREFIX}${name}`;
+  }
+};
+
+// src/broadcasting/channels/PresenceChannel.ts
+var PresenceChannel = class _PresenceChannel extends Channel {
+  /**
+   * Channel name prefix.
+   */
+  static PREFIX = "presence-";
+  presenceDriver;
+  constructor(name, driver) {
+    const channelName = name.startsWith(_PresenceChannel.PREFIX) ? name : `${_PresenceChannel.PREFIX}${name}`;
+    super(channelName, driver);
+    if (this.isPresenceDriver(driver)) {
+      this.presenceDriver = driver;
+    } else {
+      throw new Error(
+        `Driver does not support presence channels. Ensure the driver implements PresenceBroadcastDriver interface.`
+      );
+    }
+  }
+  /**
+   * Check if a driver supports presence.
+   */
+  isPresenceDriver(driver) {
+    return "getMembers" in driver && "addMember" in driver && "removeMember" in driver;
+  }
+  /**
+   * Get members in this channel.
+   */
+  members() {
+    return this.presenceDriver.getMembers(this.name);
+  }
+  /**
+   * Join the channel.
+   */
+  async join(member) {
+    this.presenceDriver.addMember(this.name, member);
+    await this.broadcast("presence:joining", {
+      member
+    });
+  }
+  /**
+   * Leave the channel.
+   */
+  async leave(memberId) {
+    const members = this.members();
+    const member = members.find((m) => m.id === memberId);
+    this.presenceDriver.removeMember(this.name, memberId);
+    if (member) {
+      await this.broadcast("presence:leaving", {
+        member
+      });
+    }
+  }
+  /**
+   * Check if a member is in the channel.
+   */
+  hasMember(memberId) {
+    return this.members().some((m) => m.id === memberId);
+  }
+  /**
+   * Get member by ID.
+   */
+  getMember(memberId) {
+    return this.members().find((m) => m.id === memberId);
+  }
+  /**
+   * Get member count.
+   */
+  count() {
+    return this.members().length;
+  }
+  /**
+   * Get the channel name without the presence prefix.
+   */
+  getBaseName() {
+    return this.name.startsWith(_PresenceChannel.PREFIX) ? this.name.slice(_PresenceChannel.PREFIX.length) : this.name;
+  }
+  /**
+   * Check if a channel name is a presence channel.
+   */
+  static isPresenceChannel(name) {
+    return name.startsWith(_PresenceChannel.PREFIX);
+  }
+  /**
+   * Normalize a channel name to include the presence prefix.
+   */
+  static normalize(name) {
+    return name.startsWith(_PresenceChannel.PREFIX) ? name : `${_PresenceChannel.PREFIX}${name}`;
+  }
+};
+
+// src/broadcasting/drivers/MemoryDriver.ts
+var MemoryDriver = class {
+  /**
+   * Channel subscribers.
+   */
+  subscribers = /* @__PURE__ */ new Map();
+  /**
+   * Presence channel members.
+   */
+  presenceMembers = /* @__PURE__ */ new Map();
+  /**
+   * Published events (for testing).
+   */
+  publishedEvents = [];
+  /**
+   * Publish an event to a channel.
+   */
+  async publish(channel, event, data) {
+    const broadcastEvent = {
+      channel,
+      event,
+      data,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.publishedEvents.push(broadcastEvent);
+    const callbacks = this.subscribers.get(channel);
+    if (callbacks) {
+      for (const callback of callbacks) {
+        try {
+          callback(broadcastEvent);
+        } catch (error) {
+          console.error(`Error in broadcast subscriber:`, error);
+        }
+      }
+    }
+  }
+  /**
+   * Subscribe to a channel.
+   */
+  subscribe(channel, callback) {
+    let callbacks = this.subscribers.get(channel);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.subscribers.set(channel, callbacks);
+    }
+    callbacks.add(callback);
+    return () => {
+      this.unsubscribe(channel, callback);
+    };
+  }
+  /**
+   * Unsubscribe from a channel.
+   */
+  unsubscribe(channel, callback) {
+    const callbacks = this.subscribers.get(channel);
+    if (callbacks) {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        this.subscribers.delete(channel);
+      }
+    }
+  }
+  /**
+   * Get members of a presence channel.
+   */
+  getMembers(channel) {
+    const members = this.presenceMembers.get(channel);
+    return members ? Array.from(members.values()) : [];
+  }
+  /**
+   * Add a member to a presence channel.
+   */
+  addMember(channel, member) {
+    let members = this.presenceMembers.get(channel);
+    if (!members) {
+      members = /* @__PURE__ */ new Map();
+      this.presenceMembers.set(channel, members);
+    }
+    members.set(member.id, member);
+  }
+  /**
+   * Remove a member from a presence channel.
+   */
+  removeMember(channel, memberId) {
+    const members = this.presenceMembers.get(channel);
+    if (members) {
+      members.delete(memberId);
+      if (members.size === 0) {
+        this.presenceMembers.delete(channel);
+      }
+    }
+  }
+  /**
+   * Check if a channel has subscribers.
+   */
+  hasSubscribers(channel) {
+    const callbacks = this.subscribers.get(channel);
+    return callbacks !== void 0 && callbacks.size > 0;
+  }
+  /**
+   * Get subscriber count for a channel.
+   */
+  getSubscriberCount(channel) {
+    const callbacks = this.subscribers.get(channel);
+    return callbacks ? callbacks.size : 0;
+  }
+  /**
+   * Get all channels with subscribers.
+   */
+  getChannels() {
+    return Array.from(this.subscribers.keys());
+  }
+  /**
+   * Get all presence channels.
+   */
+  getPresenceChannels() {
+    return Array.from(this.presenceMembers.keys());
+  }
+  /**
+   * Get all published events (for testing).
+   */
+  getPublishedEvents() {
+    return [...this.publishedEvents];
+  }
+  /**
+   * Get published events for a specific channel.
+   */
+  getPublishedEventsFor(channel) {
+    return this.publishedEvents.filter((e) => e.channel === channel);
+  }
+  /**
+   * Clear all data (for testing).
+   */
+  clear() {
+    this.subscribers.clear();
+    this.presenceMembers.clear();
+    this.publishedEvents = [];
+  }
+  /**
+   * Clear published events only.
+   */
+  clearPublishedEvents() {
+    this.publishedEvents = [];
+  }
+};
+
+// src/broadcasting/drivers/RedisDriver.ts
+var RedisDriver = class {
+  /**
+   * Publisher Redis client.
+   */
+  publisher;
+  /**
+   * Subscriber Redis client.
+   */
+  subscriber;
+  /**
+   * Local subscribers.
+   */
+  subscribers = /* @__PURE__ */ new Map();
+  /**
+   * Local presence members cache.
+   */
+  localPresence = /* @__PURE__ */ new Map();
+  /**
+   * Presence key prefix.
+   */
+  presencePrefix = "broadcasting:presence:";
+  /**
+   * Whether the driver is initialized.
+   */
+  initialized = false;
+  constructor(redis, options = {}) {
+    this.publisher = redis;
+    this.subscriber = redis.duplicate();
+    if (options.presencePrefix) {
+      this.presencePrefix = options.presencePrefix;
+    }
+    this.setupSubscriber();
+  }
+  /**
+   * Setup the subscriber client.
+   */
+  setupSubscriber() {
+    this.subscriber.on("message", (channel, message) => {
+      try {
+        const event = JSON.parse(message);
+        event.timestamp = new Date(event.timestamp);
+        const callbacks = this.subscribers.get(channel);
+        if (callbacks) {
+          for (const callback of callbacks) {
+            try {
+              callback(event);
+            } catch (error) {
+              console.error(`Error in broadcast subscriber:`, error);
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error parsing broadcast message:`, error);
+      }
+    });
+    this.initialized = true;
+  }
+  /**
+   * Publish an event to a channel.
+   */
+  async publish(channel, event, data) {
+    const broadcastEvent = {
+      channel,
+      event,
+      data,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    await this.publisher.publish(channel, JSON.stringify(broadcastEvent));
+  }
+  /**
+   * Subscribe to a channel.
+   */
+  subscribe(channel, callback) {
+    let callbacks = this.subscribers.get(channel);
+    const isNew = !callbacks;
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.subscribers.set(channel, callbacks);
+    }
+    callbacks.add(callback);
+    if (isNew) {
+      this.subscriber.subscribe(channel).catch((error) => {
+        console.error(`Error subscribing to Redis channel:`, error);
+      });
+    }
+    return () => {
+      this.unsubscribe(channel, callback);
+    };
+  }
+  /**
+   * Unsubscribe from a channel.
+   */
+  unsubscribe(channel, callback) {
+    const callbacks = this.subscribers.get(channel);
+    if (callbacks) {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        this.subscribers.delete(channel);
+        this.subscriber.unsubscribe(channel).catch((error) => {
+          console.error(`Error unsubscribing from Redis channel:`, error);
+        });
+      }
+    }
+  }
+  /**
+   * Get members of a presence channel.
+   */
+  getMembers(channel) {
+    const members = this.localPresence.get(channel);
+    return members ? Array.from(members.values()) : [];
+  }
+  /**
+   * Get members asynchronously from Redis.
+   */
+  async getMembersAsync(channel) {
+    const key = `${this.presencePrefix}${channel}`;
+    const data = await this.publisher.hgetall(key);
+    const members = [];
+    for (const [_, value] of Object.entries(data)) {
+      try {
+        members.push(JSON.parse(value));
+      } catch {
+      }
+    }
+    const localMembers = /* @__PURE__ */ new Map();
+    for (const member of members) {
+      localMembers.set(member.id, member);
+    }
+    this.localPresence.set(channel, localMembers);
+    return members;
+  }
+  /**
+   * Add a member to a presence channel.
+   */
+  addMember(channel, member) {
+    let members = this.localPresence.get(channel);
+    if (!members) {
+      members = /* @__PURE__ */ new Map();
+      this.localPresence.set(channel, members);
+    }
+    members.set(member.id, member);
+    const key = `${this.presencePrefix}${channel}`;
+    this.publisher.hset(key, String(member.id), JSON.stringify(member)).catch((error) => {
+      console.error(`Error adding presence member to Redis:`, error);
+    });
+  }
+  /**
+   * Remove a member from a presence channel.
+   */
+  removeMember(channel, memberId) {
+    const members = this.localPresence.get(channel);
+    if (members) {
+      members.delete(memberId);
+      if (members.size === 0) {
+        this.localPresence.delete(channel);
+      }
+    }
+    const key = `${this.presencePrefix}${channel}`;
+    this.publisher.hdel(key, String(memberId)).catch((error) => {
+      console.error(`Error removing presence member from Redis:`, error);
+    });
+  }
+  /**
+   * Check if a channel has subscribers.
+   */
+  hasSubscribers(channel) {
+    const callbacks = this.subscribers.get(channel);
+    return callbacks !== void 0 && callbacks.size > 0;
+  }
+  /**
+   * Get subscriber count for a channel.
+   */
+  getSubscriberCount(channel) {
+    const callbacks = this.subscribers.get(channel);
+    return callbacks ? callbacks.size : 0;
+  }
+};
+
+// src/http/request.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function parseRequestPayload(ctx) {
+  const contentType = ctx.req.header("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const body = await ctx.req.json().catch(() => ({}));
+    return isPlainObject(body) ? body : {};
+  }
+  if (typeof ctx.req.parseBody === "function") {
+    const form = await ctx.req.parseBody();
+    return Object.fromEntries(
+      Object.entries(form).map(([key, value]) => [key, Array.isArray(value) ? value[0] : value])
+    );
+  }
+  return {};
+}
+
+// src/broadcasting/BroadcastManager.ts
+var BroadcastManager = class {
+  /**
+   * Default driver name.
+   */
+  defaultDriver = "memory";
+  /**
+   * Driver factories.
+   */
+  driverFactories = /* @__PURE__ */ new Map();
+  /**
+   * Resolved drivers.
+   */
+  resolvedDrivers = /* @__PURE__ */ new Map();
+  /**
+   * Channel registrations.
+   */
+  channelRegistrations = [];
+  /**
+   * SSE clients.
+   */
+  sseClients = /* @__PURE__ */ new Map();
+  /**
+   * WebSocket clients.
+   */
+  wsClients = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    if (options.default) {
+      this.defaultDriver = options.default;
+    }
+    if (options.drivers) {
+      for (const [name, factory] of Object.entries(options.drivers)) {
+        this.registerDriver(name, factory);
+      }
+    }
+    if (!this.driverFactories.has("memory")) {
+      this.registerDriver("memory", () => new MemoryDriver());
+    }
+  }
+  /**
+   * Register a driver factory.
+   */
+  registerDriver(name, factory) {
+    this.driverFactories.set(name, factory);
+    return this;
+  }
+  /**
+   * Get a driver by name.
+   */
+  driver(name) {
+    const driverName = name ?? this.defaultDriver;
+    const resolved = this.resolvedDrivers.get(driverName);
+    if (resolved) {
+      return resolved;
+    }
+    const factory = this.driverFactories.get(driverName);
+    if (!factory) {
+      throw new Error(`Broadcast driver "${driverName}" not found`);
+    }
+    const driver = factory();
+    this.resolvedDrivers.set(driverName, driver);
+    return driver;
+  }
+  /**
+   * Register a public channel authorizer.
+   */
+  channel(pattern, authorizer) {
+    this.channelRegistrations.push({
+      pattern,
+      type: "public",
+      authorizer
+    });
+    return this;
+  }
+  /**
+   * Register a private channel authorizer.
+   */
+  privateChannel(pattern, authorizer) {
+    this.channelRegistrations.push({
+      pattern: PrivateChannel.normalize(pattern),
+      type: "private",
+      authorizer
+    });
+    return this;
+  }
+  /**
+   * Register a presence channel authorizer.
+   */
+  presenceChannel(pattern, authorizer) {
+    this.channelRegistrations.push({
+      pattern: PresenceChannel.normalize(pattern),
+      type: "presence",
+      authorizer
+    });
+    return this;
+  }
+  /**
+   * Broadcast an event to a channel.
+   */
+  async broadcast(channelName, event, data) {
+    await this.driver().publish(channelName, event, data);
+  }
+  /**
+   * Get a public channel.
+   */
+  toChannel(name) {
+    return new Channel(name, this.driver());
+  }
+  /**
+   * Get a private channel.
+   */
+  toPrivate(name) {
+    return new PrivateChannel(name, this.driver());
+  }
+  /**
+   * Get a presence channel.
+   */
+  toPresence(name) {
+    return new PresenceChannel(name, this.driver());
+  }
+  /**
+   * Authorize a channel for a user.
+   */
+  async authorize(channelName, user) {
+    const registration = this.findChannelRegistration(channelName);
+    if (!registration) {
+      return true;
+    }
+    if (registration.type === "presence") {
+      const presenceAuth = registration.authorizer;
+      return await presenceAuth(channelName, user);
+    }
+    return await registration.authorizer(channelName, user);
+  }
+  /**
+   * Find channel registration for a channel name.
+   */
+  findChannelRegistration(channelName) {
+    return this.channelRegistrations.find(
+      (reg) => this.matchPattern(reg.pattern, channelName)
+    );
+  }
+  /**
+   * Match a channel name against a pattern.
+   */
+  matchPattern(pattern, channelName) {
+    const regexPattern = pattern.replace(/\{[^}]+\}/g, "[^.]+").replace(/\*\*/g, ".+").replace(/\*/g, "[^.]+");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(channelName);
+  }
+  /**
+   * Create SSE middleware.
+   */
+  sseMiddleware(options = {}) {
+    const pingInterval = options.pingInterval ?? 3e4;
+    const retry = options.retry ?? 3e3;
+    return async (ctx) => {
+      const clientId = this.generateClientId();
+      const encoder = new TextEncoder();
+      const manager = this;
+      let controller = null;
+      let client = null;
+      let pingTimer = null;
+      const sendRaw = (message) => {
+        if (!controller) return;
+        controller.enqueue(encoder.encode(message));
+      };
+      const cleanup = () => {
+        if (pingTimer) {
+          clearInterval(pingTimer);
+          pingTimer = null;
+        }
+        if (client) {
+          manager.sseClients.delete(client.id);
+          client = null;
+        }
+        if (controller) {
+          try {
+            controller.close();
+          } catch {
+          }
+          controller = null;
+        }
+      };
+      const stream = new ReadableStream({
+        start(streamController) {
+          controller = streamController;
+          client = {
+            id: clientId,
+            userId: void 0,
+            channels: /* @__PURE__ */ new Set(),
+            send: (event, data) => {
+              const message = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+              sendRaw(message);
+            },
+            close: cleanup
+          };
+          manager.sseClients.set(clientId, client);
+          sendRaw(`retry: ${retry}
+
+`);
+          pingTimer = setInterval(() => {
+            try {
+              client?.send("ping", { time: Date.now() });
+            } catch {
+              cleanup();
+            }
+          }, pingInterval);
+        },
+        cancel() {
+          cleanup();
+        }
+      });
+      ctx.req.raw.signal.addEventListener("abort", cleanup, { once: true });
+      return new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    };
+  }
+  /**
+   * Create auth middleware for channel authorization.
+   */
+  authMiddleware(options = {}) {
+    return async (ctx) => {
+      const getUser = options.getUser ?? ((c) => c.auth?.user);
+      const user = await getUser(ctx);
+      const payload = await parseRequestPayload(ctx);
+      const channel = typeof payload.channel === "string" ? payload.channel : void 0;
+      const channels = Array.isArray(payload.channels) ? payload.channels.filter((value) => typeof value === "string") : typeof payload.channels === "string" ? [payload.channels] : channel ? [channel] : [];
+      if (channels.length === 0) {
+        return ctx.json({ error: "No channel specified" }, 400);
+      }
+      const results = {};
+      for (const ch of channels) {
+        const authResult = await this.authorize(ch, user);
+        if (authResult === false || authResult === null) {
+          results[ch] = { authorized: false };
+        } else if (authResult === true) {
+          results[ch] = { authorized: true };
+        } else {
+          results[ch] = {
+            authorized: true,
+            member: authResult
+          };
+        }
+      }
+      return ctx.json(results);
+    };
+  }
+  /**
+   * Subscribe a client to a channel.
+   */
+  subscribeClient(clientId, channel) {
+    const client = this.sseClients.get(clientId);
+    if (!client) return false;
+    client.channels.add(channel);
+    this.driver().subscribe(channel, (event) => {
+      if (client.channels.has(channel)) {
+        client.send(event.event, event.data);
+      }
+    });
+    return true;
+  }
+  /**
+   * Register a WebSocket client and return its generated client ID.
+   */
+  registerWebSocketClient(client) {
+    const clientId = this.generateClientId("ws");
+    this.wsClients.set(clientId, {
+      ...client,
+      id: clientId,
+      channels: /* @__PURE__ */ new Set()
+    });
+    return clientId;
+  }
+  /**
+   * Remove a WebSocket client and close the underlying connection.
+   */
+  removeWebSocketClient(clientId) {
+    const client = this.wsClients.get(clientId);
+    if (!client) return false;
+    this.wsClients.delete(clientId);
+    client.close();
+    return true;
+  }
+  /**
+   * Subscribe a WebSocket client to a channel.
+   */
+  subscribeWebSocketClient(clientId, channel) {
+    const client = this.wsClients.get(clientId);
+    if (!client) return false;
+    client.channels.add(channel);
+    this.driver().subscribe(channel, async (event) => {
+      if (client.channels.has(channel)) {
+        await client.send(event.event, event.data);
+      }
+    });
+    return true;
+  }
+  /**
+   * Unsubscribe a WebSocket client from a channel.
+   */
+  unsubscribeWebSocketClient(clientId, channel) {
+    const client = this.wsClients.get(clientId);
+    if (!client) return false;
+    client.channels.delete(channel);
+    return true;
+  }
+  /**
+   * Get a WebSocket client by ID.
+   */
+  getWebSocketClient(clientId) {
+    return this.wsClients.get(clientId);
+  }
+  /**
+   * Get all WebSocket clients.
+   */
+  getWebSocketClients() {
+    return Array.from(this.wsClients.values());
+  }
+  /**
+   * Unsubscribe a client from a channel.
+   */
+  unsubscribeClient(clientId, channel) {
+    const client = this.sseClients.get(clientId);
+    if (!client) return false;
+    client.channels.delete(channel);
+    return true;
+  }
+  /**
+   * Get SSE client by ID.
+   */
+  getClient(clientId) {
+    return this.sseClients.get(clientId);
+  }
+  /**
+   * Get all SSE clients.
+   */
+  getClients() {
+    return Array.from(this.sseClients.values());
+  }
+  /**
+   * Get clients subscribed to a channel.
+   */
+  getChannelClients(channel) {
+    return this.getClients().filter((client) => client.channels.has(channel));
+  }
+  /**
+   * Generate a unique client ID.
+   */
+  generateClientId(prefix = "sse") {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 10);
+    return `${prefix}_${timestamp}${random}`;
+  }
+};
+var globalBroadcastManager = null;
+function setBroadcastManager(manager) {
+  globalBroadcastManager = manager;
+}
+function getBroadcastManager() {
+  if (!globalBroadcastManager) {
+    throw new Error("BroadcastManager not initialized. Call setBroadcastManager() first.");
+  }
+  return globalBroadcastManager;
+}
+function createBroadcastManager(options) {
+  return new BroadcastManager(options);
+}
+
+// src/broadcasting/typed.ts
+function createTypedBroadcaster(manager) {
+  return {
+    broadcast(channel, event, payload) {
+      return manager.broadcast(channel, event, payload);
+    },
+    toChannel(channel) {
+      return wrapChannel(channel, manager.toChannel(channel));
+    },
+    toPrivate(channel) {
+      return wrapChannel(channel, manager.toPrivate(channel));
+    },
+    toPresence(channel) {
+      return wrapChannel(channel, manager.toPresence(channel));
+    }
+  };
+}
+function wrapChannel(name, channel) {
+  return {
+    name,
+    broadcast(event, payload) {
+      return channel.broadcast(event, payload);
+    }
+  };
+}
+export {
+  BroadcastManager,
+  Channel,
+  MemoryDriver,
+  PresenceChannel,
+  PrivateChannel,
+  RedisDriver,
+  createBroadcastManager,
+  createTypedBroadcaster,
+  getBroadcastManager,
+  setBroadcastManager
+};