@cendarsoss/pusher-js 8.4.11

package/src/core/channels/encrypted_channel.ts

@@ -0,0 +1,150 @@
+import PrivateChannel from './private_channel';
+import * as Errors from '../errors';
+import Logger from '../logger';
+import Pusher from '../pusher';
+import { decode as encodeUTF8 } from '@stablelib/utf8';
+import { decode as decodeBase64 } from '@stablelib/base64';
+import Dispatcher from '../events/dispatcher';
+import { PusherEvent } from '../connection/protocol/message-types';
+import {
+  ChannelAuthorizationData,
+  ChannelAuthorizationCallback,
+} from '../auth/options';
+import * as nacl from 'tweetnacl';
+
+/** Extends private channels to provide encrypted channel interface.
+ *
+ * @param {String} name
+ * @param {Pusher} pusher
+ */
+export default class EncryptedChannel extends PrivateChannel {
+  key: Uint8Array = null;
+  nacl: nacl;
+
+  constructor(name: string, pusher: Pusher, nacl: nacl) {
+    super(name, pusher);
+    this.nacl = nacl;
+  }
+
+  /** Authorizes the connection to use the channel.
+   *
+   * @param  {String} socketId
+   * @param  {Function} callback
+   */
+  authorize(socketId: string, callback: ChannelAuthorizationCallback) {
+    super.authorize(
+      socketId,
+      (error: Error | null, authData: ChannelAuthorizationData) => {
+        if (error) {
+          callback(error, authData);
+          return;
+        }
+        let sharedSecret = authData['shared_secret'];
+        if (!sharedSecret) {
+          callback(
+            new Error(
+              `No shared_secret key in auth payload for encrypted channel: ${this.name}`,
+            ),
+            null,
+          );
+          return;
+        }
+        this.key = decodeBase64(sharedSecret);
+        delete authData['shared_secret'];
+        callback(null, authData);
+      },
+    );
+  }
+
+  trigger(event: string, data: any): boolean {
+    throw new Errors.UnsupportedFeature(
+      'Client events are not currently supported for encrypted channels',
+    );
+  }
+
+  /** Handles an event. For internal use only.
+   *
+   * @param {PusherEvent} event
+   */
+  handleEvent(event: PusherEvent) {
+    var eventName = event.event;
+    var data = event.data;
+    if (
+      eventName.indexOf('pusher_internal:') === 0 ||
+      eventName.indexOf('pusher:') === 0
+    ) {
+      super.handleEvent(event);
+      return;
+    }
+    this.handleEncryptedEvent(eventName, data);
+  }
+
+  private handleEncryptedEvent(event: string, data: any): void {
+    if (!this.key) {
+      Logger.debug(
+        'Received encrypted event before key has been retrieved from the authEndpoint',
+      );
+      return;
+    }
+    if (!data.ciphertext || !data.nonce) {
+      Logger.error(
+        'Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: ' +
+          data,
+      );
+      return;
+    }
+    let cipherText = decodeBase64(data.ciphertext);
+    if (cipherText.length < this.nacl.secretbox.overheadLength) {
+      Logger.error(
+        `Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${cipherText.length}`,
+      );
+      return;
+    }
+    let nonce = decodeBase64(data.nonce);
+    if (nonce.length < this.nacl.secretbox.nonceLength) {
+      Logger.error(
+        `Expected encrypted event nonce length to be ${this.nacl.secretbox.nonceLength}, got: ${nonce.length}`,
+      );
+      return;
+    }
+
+    let bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
+    if (bytes === null) {
+      Logger.debug(
+        'Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint...',
+      );
+      // Try a single time to retrieve a new auth key and decrypt the event with it
+      // If this fails, a new key will be requested when a new message is received
+      this.authorize(this.pusher.connection.socket_id, (error, authData) => {
+        if (error) {
+          Logger.error(
+            `Failed to make a request to the authEndpoint: ${authData}. Unable to fetch new key, so dropping encrypted event`,
+          );
+          return;
+        }
+        bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
+        if (bytes === null) {
+          Logger.error(
+            `Failed to decrypt event with new key. Dropping encrypted event`,
+          );
+          return;
+        }
+        this.emit(event, this.getDataToEmit(bytes));
+        return;
+      });
+      return;
+    }
+    this.emit(event, this.getDataToEmit(bytes));
+  }
+
+  // Try and parse the decrypted bytes as JSON. If we can't parse it, just
+  // return the utf-8 string
+  getDataToEmit(bytes: Uint8Array): string {
+    let raw = encodeUTF8(bytes);
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+}

package/src/core/channels/filter.ts

@@ -0,0 +1,342 @@
+// sockudo-js/src/core/channels/filter.ts
+
+/**
+ * Filter node structure for publication filtering by tags.
+ *
+ * This structure matches the server-side FilterNode format for zero-allocation
+ * evaluation during message broadcast.
+ */
+export interface FilterNode {
+  /** Logical operator: "and", "or", "not" (if present, this is a branch node) */
+  op?: string;
+
+  /** Key for comparison (leaf nodes only) */
+  key?: string;
+
+  /** Comparison operator: "eq", "neq", "in", "nin", "ex", "nex", "sw", "ew", "ct", "gt", "gte", "lt", "lte" */
+  cmp?: string;
+
+  /** Single value for most comparisons */
+  val?: string;
+
+  /** Multiple values for set operations (in, nin) */
+  vals?: string[];
+
+  /** Child nodes for logical operations */
+  nodes?: FilterNode[];
+}
+
+/**
+ * Builder for constructing filter nodes programmatically.
+ *
+ * Provides a clean API for creating complex filters without dealing with
+ * the internal FilterNode structure directly.
+ *
+ * @example
+ * ```typescript
+ * // Simple equality filter
+ * const filter = Filter.eq("event_type", "goal");
+ *
+ * // Complex nested filter
+ * const filter = Filter.or(
+ *   Filter.eq("event_type", "goal"),
+ *   Filter.and(
+ *     Filter.eq("event_type", "shot"),
+ *     Filter.gte("xG", "0.8")
+ *   )
+ * );
+ * ```
+ */
+export const Filter = {
+  // Comparison operators
+
+  /**
+   * Creates an equality comparison: key == val
+   * @param key The tag key to compare
+   * @param val The value to compare against
+   * @returns FilterNode for equality comparison
+   */
+  eq: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "eq",
+    val
+  }),
+
+  /**
+   * Creates an inequality comparison: key != val
+   * @param key The tag key to compare
+   * @param val The value to compare against
+   * @returns FilterNode for inequality comparison
+   */
+  neq: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "neq",
+    val
+  }),
+
+  /**
+   * Creates a set membership comparison: key in [vals...]
+   * @param key The tag key to compare
+   * @param vals Array of values for set membership
+   * @returns FilterNode for set membership comparison
+   */
+  in: (key: string, vals: string[]): FilterNode => ({
+    key,
+    cmp: "in",
+    vals
+  }),
+
+  /**
+   * Creates a set non-membership comparison: key not in [vals...]
+   * @param key The tag key to compare
+   * @param vals Array of values for set non-membership
+   * @returns FilterNode for set non-membership comparison
+   */
+  nin: (key: string, vals: string[]): FilterNode => ({
+    key,
+    cmp: "nin",
+    vals
+  }),
+
+  /**
+   * Creates an existence check: key exists
+   * @param key The tag key to check for existence
+   * @returns FilterNode for existence check
+   */
+  exists: (key: string): FilterNode => ({
+    key,
+    cmp: "ex"
+  }),
+
+  /**
+   * Creates a non-existence check: key does not exist
+   * @param key The tag key to check for non-existence
+   * @returns FilterNode for non-existence check
+   */
+  notExists: (key: string): FilterNode => ({
+    key,
+    cmp: "nex"
+  }),
+
+  /**
+   * Creates a starts-with comparison: key starts with val
+   * @param key The tag key to compare
+   * @param val The prefix to match
+   * @returns FilterNode for starts-with comparison
+   */
+  startsWith: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "sw",
+    val
+  }),
+
+  /**
+   * Creates an ends-with comparison: key ends with val
+   * @param key The tag key to compare
+   * @param val The suffix to match
+   * @returns FilterNode for ends-with comparison
+   */
+  endsWith: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "ew",
+    val
+  }),
+
+  /**
+   * Creates a contains comparison: key contains val
+   * @param key The tag key to compare
+   * @param val The substring to match
+   * @returns FilterNode for contains comparison
+   */
+  contains: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "ct",
+    val
+  }),
+
+  /**
+   * Creates a greater-than comparison: key > val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for greater-than comparison
+   */
+  gt: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "gt",
+    val
+  }),
+
+  /**
+   * Creates a greater-than-or-equal comparison: key >= val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for greater-than-or-equal comparison
+   */
+  gte: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "gte",
+    val
+  }),
+
+  /**
+   * Creates a less-than comparison: key < val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for less-than comparison
+   */
+  lt: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "lt",
+    val
+  }),
+
+  /**
+   * Creates a less-than-or-equal comparison: key <= val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for less-than-or-equal comparison
+   */
+  lte: (key: string, val: string): FilterNode => ({
+    key,
+    cmp: "lte",
+    val
+  }),
+
+  // Logical operators
+
+  /**
+   * Creates an AND logical operation: all children must match
+   * @param nodes Child filter nodes to combine with AND
+   * @returns FilterNode for AND operation
+   */
+  and: (...nodes: FilterNode[]): FilterNode => ({
+    op: "and",
+    nodes
+  }),
+
+  /**
+   * Creates an OR logical operation: at least one child must match
+   * @param nodes Child filter nodes to combine with OR
+   * @returns FilterNode for OR operation
+   */
+  or: (...nodes: FilterNode[]): FilterNode => ({
+    op: "or",
+    nodes
+  }),
+
+  /**
+   * Creates a NOT logical operation: negates the child
+   * @param node Child filter node to negate
+   * @returns FilterNode for NOT operation
+   */
+  not: (node: FilterNode): FilterNode => ({
+    op: "not",
+    nodes: [node]
+  })
+};
+
+/**
+ * Validates a filter node structure.
+ *
+ * @param filter The filter node to validate
+ * @returns Error message if invalid, null if valid
+ */
+export function validateFilter(filter: FilterNode): string | null {
+  if (filter.op) {
+    // Branch node - logical operation
+    const op = filter.op;
+
+    if (!["and", "or", "not"].includes(op)) {
+      return `Invalid logical operator: ${op}`;
+    }
+
+    if (!filter.nodes || !Array.isArray(filter.nodes)) {
+      return `Logical operation '${op}' requires nodes array`;
+    }
+
+    if (op === "not" && filter.nodes.length !== 1) {
+      return `NOT operation requires exactly one child node, got ${filter.nodes.length}`;
+    }
+
+    if ((op === "and" || op === "or") && filter.nodes.length === 0) {
+      return `${op.toUpperCase()} operation requires at least one child node`;
+    }
+
+    // Validate all children recursively
+    for (let i = 0; i < filter.nodes.length; i++) {
+      const childError = validateFilter(filter.nodes[i]);
+      if (childError) {
+        return `Child node ${i}: ${childError}`;
+      }
+    }
+  } else {
+    // Leaf node - comparison
+    if (!filter.key) {
+      return "Leaf node requires a key";
+    }
+
+    if (!filter.cmp) {
+      return "Leaf node requires a comparison operator";
+    }
+
+    const validOps = ["eq", "neq", "in", "nin", "ex", "nex", "sw", "ew", "ct", "gt", "gte", "lt", "lte"];
+    if (!validOps.includes(filter.cmp)) {
+      return `Invalid comparison operator: ${filter.cmp}`;
+    }
+
+    // Check value requirements based on operator
+    if (filter.cmp === "in" || filter.cmp === "nin") {
+      if (!filter.vals || !Array.isArray(filter.vals) || filter.vals.length === 0) {
+        return `${filter.cmp} operation requires non-empty vals array`;
+      }
+    } else if (filter.cmp === "ex" || filter.cmp === "nex") {
+      // Existence checks don't need values
+    } else {
+      if (!filter.val) {
+        return `${filter.cmp} operation requires a val`;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Example filter patterns for common use cases
+ */
+export const FilterExamples = {
+  /**
+   * Filter for a specific event type
+   * @example Filter.eq("event_type", "goal")
+   */
+  eventType: (type: string) => Filter.eq("event_type", type),
+
+  /**
+   * Filter for events in a set of types
+   * @example FilterExamples.eventTypes(["goal", "shot"])
+   */
+  eventTypes: (types: string[]) => Filter.in("event_type", types),
+
+  /**
+   * Filter for numeric range
+   * @example FilterExamples.range("xG", "0.5", "0.9")
+   */
+  range: (key: string, min: string, max: string) =>
+    Filter.and(
+      Filter.gte(key, min),
+      Filter.lte(key, max)
+    ),
+
+  /**
+   * Filter for goals OR high-probability shots
+   * @example FilterExamples.importantEvents("0.8")
+   */
+  importantEvents: (xGThreshold: string) =>
+    Filter.or(
+      Filter.eq("event_type", "goal"),
+      Filter.and(
+        Filter.eq("event_type", "shot"),
+        Filter.gte("xG", xGThreshold)
+      )
+    )
+};

package/src/core/channels/members.ts

@@ -0,0 +1,80 @@
+import * as Collections from '../utils/collections';
+
+/** Represents a collection of members of a presence channel. */
+export default class Members {
+  members: any;
+  count: number;
+  myID: any;
+  me: any;
+
+  constructor() {
+    this.reset();
+  }
+
+  /** Returns member's info for given id.
+   *
+   * Resulting object containts two fields - id and info.
+   *
+   * @param {Number} id
+   * @return {Object} member's info or null
+   */
+  get(id: string): any {
+    if (Object.prototype.hasOwnProperty.call(this.members, id)) {
+      return {
+        id: id,
+        info: this.members[id],
+      };
+    } else {
+      return null;
+    }
+  }
+
+  /** Calls back for each member in unspecified order.
+   *
+   * @param  {Function} callback
+   */
+  each(callback: Function) {
+    Collections.objectApply(this.members, (member, id) => {
+      callback(this.get(id));
+    });
+  }
+
+  /** Updates the id for connected member. For internal use only. */
+  setMyID(id: string) {
+    this.myID = id;
+  }
+
+  /** Handles subscription data. For internal use only. */
+  onSubscription(subscriptionData: any) {
+    this.members = subscriptionData.presence.hash;
+    this.count = subscriptionData.presence.count;
+    this.me = this.get(this.myID);
+  }
+
+  /** Adds a new member to the collection. For internal use only. */
+  addMember(memberData: any) {
+    if (this.get(memberData.user_id) === null) {
+      this.count++;
+    }
+    this.members[memberData.user_id] = memberData.user_info;
+    return this.get(memberData.user_id);
+  }
+
+  /** Adds a member from the collection. For internal use only. */
+  removeMember(memberData: any) {
+    var member = this.get(memberData.user_id);
+    if (member) {
+      delete this.members[memberData.user_id];
+      this.count--;
+    }
+    return member;
+  }
+
+  /** Resets the collection to the initial state. For internal use only. */
+  reset() {
+    this.members = {};
+    this.count = 0;
+    this.myID = null;
+    this.me = null;
+  }
+}

package/src/core/channels/metadata.ts

@@ -0,0 +1,5 @@
+interface Metadata {
+  user_id?: string;
+}
+
+export default Metadata;

package/src/core/channels/presence_channel.ts

@@ -0,0 +1,113 @@
+import PrivateChannel from './private_channel';
+import Logger from '../logger';
+import Members from './members';
+import Pusher from '../pusher';
+import UrlStore from 'core/utils/url_store';
+import { PusherEvent } from '../connection/protocol/message-types';
+import Metadata from './metadata';
+import { ChannelAuthorizationData } from '../auth/options';
+
+export default class PresenceChannel extends PrivateChannel {
+  members: Members;
+
+  /** Adds presence channel functionality to private channels.
+   *
+   * @param {String} name
+   * @param {Pusher} pusher
+   */
+  constructor(name: string, pusher: Pusher) {
+    super(name, pusher);
+    this.members = new Members();
+  }
+
+  /** Authorizes the connection as a member of the channel.
+   *
+   * @param  {String} socketId
+   * @param  {Function} callback
+   */
+  authorize(socketId: string, callback: Function) {
+    super.authorize(socketId, async (error, authData) => {
+      if (!error) {
+        authData = authData as ChannelAuthorizationData;
+        if (authData.channel_data != null) {
+          var channelData = JSON.parse(authData.channel_data);
+          this.members.setMyID(channelData.user_id);
+        } else {
+          await this.pusher.user.signinDonePromise;
+          if (this.pusher.user.user_data != null) {
+            // If the user is signed in, get the id of the authenticated user
+            // and allow the presence authorization to continue.
+            this.members.setMyID(this.pusher.user.user_data.id);
+          } else {
+            let suffix = UrlStore.buildLogSuffix('authorizationEndpoint');
+            Logger.error(
+              `Invalid auth response for channel '${this.name}', ` +
+                `expected 'channel_data' field. ${suffix}, ` +
+                `or the user should be signed in.`,
+            );
+            callback('Invalid auth response');
+            return;
+          }
+        }
+      }
+      callback(error, authData);
+    });
+  }
+
+  /** Handles presence and subscription events. For internal use only.
+   *
+   * @param {PusherEvent} event
+   */
+  handleEvent(event: PusherEvent) {
+    var eventName = event.event;
+    if (eventName.indexOf('pusher_internal:') === 0) {
+      this.handleInternalEvent(event);
+    } else {
+      var data = event.data;
+      var metadata: Metadata = {};
+      if (event.user_id) {
+        metadata.user_id = event.user_id;
+      }
+      this.emit(eventName, data, metadata);
+    }
+  }
+  handleInternalEvent(event: PusherEvent) {
+    var eventName = event.event;
+    var data = event.data;
+    switch (eventName) {
+      case 'pusher_internal:subscription_succeeded':
+        this.handleSubscriptionSucceededEvent(event);
+        break;
+      case 'pusher_internal:subscription_count':
+        this.handleSubscriptionCountEvent(event);
+        break;
+      case 'pusher_internal:member_added':
+        var addedMember = this.members.addMember(data);
+        this.emit('pusher:member_added', addedMember);
+        break;
+      case 'pusher_internal:member_removed':
+        var removedMember = this.members.removeMember(data);
+        if (removedMember) {
+          this.emit('pusher:member_removed', removedMember);
+        }
+        break;
+    }
+  }
+
+  handleSubscriptionSucceededEvent(event: PusherEvent) {
+    this.subscriptionPending = false;
+    this.subscribed = true;
+    if (this.subscriptionCancelled) {
+      this.pusher.unsubscribe(this.name);
+    } else {
+      this.members.onSubscription(event.data);
+      this.emit('pusher:subscription_succeeded', this.members);
+    }
+  }
+
+  /** Resets the channel state, including members map. For internal use only. */
+  disconnect() {
+    this.members.reset();
+    super.disconnect();
+  }
+}