@cendarsoss/pusher-js 8.4.11

package/interactive/server.js

@@ -0,0 +1,246 @@
+// server.js
+require("dotenv").config();
+const express = require("express");
+const bodyParser = require("body-parser");
+const Pusher = require("pusher");
+const crypto = require("crypto");
+
+const app = express();
+const port = process.env.BACKEND_PORT || 3000;
+
+// Configure Pusher for your WebSocket server
+const pusher = new Pusher({
+  appId: process.env.PUSHER_APP_ID,
+  key: process.env.PUSHER_APP_KEY,
+  secret: process.env.PUSHER_APP_SECRET,
+  cluster: "mt1",
+  host: process.env.PUSHER_HOST,
+  port: process.env.PUSHER_PORT,
+  useTLS: process.env.PUSHER_USE_TLS === "true",
+});
+
+console.log("Pusher Server SDK configured for:", {
+  appId: process.env.PUSHER_APP_ID,
+  key: process.env.PUSHER_APP_KEY ? "***" : "Not Set",
+  secret: process.env.PUSHER_APP_SECRET ? "***" : "Not Set",
+  host: process.env.PUSHER_HOST,
+  port: process.env.PUSHER_PORT,
+  useTLS: process.env.PUSHER_USE_TLS === "true",
+});
+
+// Store received webhooks and active channels
+let receivedWebhooks = [];
+let activeChannels = new Set();
+let eventHistory = [];
+
+// Middleware
+app.use(express.static("public"));
+app.use(
+    bodyParser.json({
+      verify: (req, res, buf) => {
+        req.rawBody = buf;
+      },
+    })
+);
+app.use(bodyParser.urlencoded({ extended: false }));
+
+// Routes
+
+// Frontend config endpoint
+app.get("/config", (req, res) => {
+  res.json({
+    pusherKey: process.env.PUSHER_APP_KEY,
+    pusherHost: process.env.PUSHER_HOST,
+    pusherPort: process.env.PUSHER_PORT,
+    pusherUseTLS: process.env.PUSHER_USE_TLS === "true",
+    authEndpoint: `${process.env.BACKEND_BASE_URL}/pusher/auth`,
+    pusherCluster: "mt1",
+  });
+});
+
+// Authentication endpoint
+app.post("/pusher/auth", (req, res) => {
+  const socketId = req.body.socket_id;
+  const channel = req.body.channel_name;
+
+  console.log(`Auth attempt for socket_id: ${socketId}, channel: ${channel}`);
+
+  const MOCK_USER_ID = `user_${Math.random().toString(36).substr(2, 9)}`;
+  const MOCK_USER_INFO = {
+    name: `Test User ${MOCK_USER_ID.split("_")[1]}`,
+    id: MOCK_USER_ID,
+    avatar: `https://ui-avatars.com/api/?name=${MOCK_USER_ID}&background=random`,
+  };
+
+  try {
+    if (channel.startsWith("private-")) {
+      const authResponse = pusher.authorizeChannel(socketId, channel);
+      console.log("Auth success (private):", authResponse);
+      res.send(authResponse);
+    } else if (channel.startsWith("presence-")) {
+      const presenceData = {
+        user_id: MOCK_USER_ID,
+        user_info: MOCK_USER_INFO,
+      };
+      const authResponse = pusher.authorizeChannel(
+        socketId,
+        channel,
+        presenceData,
+      );
+      console.log("Auth success (presence):", authResponse);
+      res.send(authResponse);
+    } else {
+      console.error(
+        `Auth failed: Channel ${channel} is not private or presence.`,
+      );
+      res.status(403).send("Forbidden: Channel is not private or presence");
+    }
+  } catch (error) {
+    console.error("Auth error:", error);
+    res.status(500).send(`Authentication error: ${error.message}`);
+  }
+});
+
+// Webhook endpoint
+app.post("/pusher/webhooks", (req, res) => {
+  console.log("\n--- Webhook Received ---");
+
+  const receivedSignature = req.headers["x-pusher-signature"];
+  const expectedSignature = crypto
+    .createHmac("sha256", process.env.PUSHER_APP_SECRET)
+    .update(req.rawBody)
+    .digest("hex");
+
+  if (receivedSignature && receivedSignature !== expectedSignature) {
+    console.error("Webhook signature invalid!");
+    return res.status(403).send("Webhook signature invalid");
+  }
+
+  const webhookBody = req.body;
+  console.log("Webhook Body:", JSON.stringify(webhookBody, null, 2));
+
+  const webhookData = {
+    timestamp: new Date().toISOString(),
+    headers: req.headers,
+    body: webhookBody,
+  };
+  receivedWebhooks.unshift(webhookData);
+  if (receivedWebhooks.length > 100) {
+    receivedWebhooks.pop();
+  }
+
+  res.status(200).json({ message: "Webhook received" });
+});
+
+// Server-side event trigger endpoint
+app.post("/trigger-event", async (req, res) => {
+  try {
+    const { channel, event, data } = req.body;
+
+    if (!channel || !event) {
+      return res.status(400).json({ error: "Channel and event are required" });
+    }
+
+    console.log(`Triggering server event: ${event} on ${channel}`);
+
+    const result = await pusher.trigger(channel, event, data || {});
+
+    const eventRecord = {
+      timestamp: new Date().toISOString(),
+      type: "server-triggered",
+      channel,
+      event,
+      data: data || {},
+      result,
+    };
+    eventHistory.unshift(eventRecord);
+    if (eventHistory.length > 100) {
+      eventHistory.pop();
+    }
+
+    res.json({ success: true, result });
+  } catch (error) {
+    console.error("Error triggering event:", error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Batch events endpoint
+app.post("/trigger-batch-events", async (req, res) => {
+  try {
+    const { channel, count = 5, delay = 1000 } = req.body;
+
+    if (!channel) {
+      return res.status(400).json({ error: "Channel is required" });
+    }
+
+    res.json({ success: true, message: `Triggering ${count} events...` });
+
+    // Trigger events with delay
+    for (let i = 1; i <= count; i++) {
+      setTimeout(
+        async () => {
+          try {
+            await pusher.trigger(channel, "batch-test", {
+              message: `Batch message ${i} of ${count}`,
+              timestamp: new Date().toISOString(),
+              sequence: i,
+            });
+            console.log(`Batch event ${i}/${count} sent to ${channel}`);
+          } catch (error) {
+            console.error(`Error sending batch event ${i}:`, error);
+          }
+        },
+        (i - 1) * delay,
+      );
+    }
+  } catch (error) {
+    console.error("Error triggering batch events:", error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Get various logs
+app.get("/webhooks-log", (req, res) => {
+  res.json(receivedWebhooks);
+});
+
+app.get("/event-history", (req, res) => {
+  res.json(eventHistory);
+});
+
+app.get("/channel-info", async (req, res) => {
+  try {
+    const { channel } = req.query;
+    if (!channel) {
+      return res.status(400).json({ error: "Channel parameter required" });
+    }
+
+    const info = await pusher.get({ path: `/channels/${channel}` });
+    res.json(info);
+  } catch (error) {
+    console.error("Error getting channel info:", error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.get("/channels", async (req, res) => {
+  try {
+    const channels = await pusher.get({ path: "/channels" });
+    res.json(channels);
+  } catch (error) {
+    console.error("Error getting channels:", error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(`\n🚀 Pusher Test Backend Server`);
+  console.log(`📡 Running at ${process.env.BACKEND_BASE_URL}`);
+  console.log(`🔐 Auth Endpoint: POST /pusher/auth`);
+  console.log(`🪝 Webhook Endpoint: POST /pusher/webhooks`);
+  console.log(`⚡ Trigger Event: POST /trigger-event`);
+  console.log(`📊 Dashboard available at: ${process.env.BACKEND_BASE_URL}`);
+  console.log(`================================\n`);
+});

package/interactive/test-bundle.html

@@ -0,0 +1,89 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Bundle Test</title>
+</head>
+<body>
+    <h1>Testing Bundled Libraries</h1>
+    <div id="results"></div>
+
+    <script src="public/dist/bundle.js"></script>
+    <script>
+        // Test if all libraries are available
+        const results = document.getElementById('results');
+
+        function addResult(text, success = true) {
+            const p = document.createElement('p');
+            p.textContent = text;
+            p.style.color = success ? 'green' : 'red';
+            results.appendChild(p);
+        }
+
+        // Check Pusher
+        if (typeof Pusher !== 'undefined') {
+            addResult('✓ Pusher loaded successfully');
+            addResult(`  Version: ${Pusher.VERSION || 'unknown'}`);
+        } else {
+            addResult('✗ Pusher not found', false);
+        }
+
+        // Check fossil-delta
+        if (typeof fossilDelta !== 'undefined') {
+            addResult('✓ fossil-delta loaded successfully');
+            if (typeof fossilDelta.create === 'function' && typeof fossilDelta.apply === 'function') {
+                addResult('  Functions: create() and apply() available');
+            }
+        } else {
+            addResult('✗ fossil-delta not found', false);
+        }
+
+        // Check vcdiff
+        if (typeof vcdiff !== 'undefined' && typeof vcdiff.decode === 'function') {
+            addResult('✓ vcdiff decoder loaded successfully');
+            addResult('  Function: decode() available');
+        } else {
+            addResult('✗ vcdiff decoder not found', false);
+        }
+
+        // Quick test of fossil-delta
+        try {
+            const source = new TextEncoder().encode('Hello World');
+            const target = new TextEncoder().encode('Hello JavaScript');
+            const delta = fossilDelta.create(source, target);
+            const result = fossilDelta.apply(source, delta);
+            const resultText = new TextDecoder().decode(result);
+            if (resultText === 'Hello JavaScript') {
+                addResult('✓ fossil-delta test passed: ' + resultText);
+            } else {
+                addResult('✗ fossil-delta test failed', false);
+            }
+        } catch (e) {
+            addResult('✗ fossil-delta test error: ' + e.message, false);
+        }
+
+        // Test connecting to Pusher
+        try {
+            const pusher = new Pusher('app-key', {
+                wsHost: 'localhost',
+                wsPort: 6001,
+                forceTLS: false,
+                disableStats: true,
+                enabledTransports: ['ws'],
+                cluster: 'mt1'
+            });
+
+            pusher.connection.bind('connected', () => {
+                addResult('✓ Successfully connected to Pusher/Sockudo');
+                pusher.disconnect();
+            });
+
+            pusher.connection.bind('error', (err) => {
+                addResult('✗ Connection error: ' + err.message, false);
+            });
+        } catch (e) {
+            addResult('✗ Pusher initialization error: ' + e.message, false);
+        }
+    </script>
+</body>
+</html>

package/interactive/test-delta.js

@@ -0,0 +1,146 @@
+// Test delta compression with bundled libraries
+const http = require('http');
+
+// Test configuration
+const config = {
+    host: 'localhost',
+    port: 3000,
+    channel: 'test-channel'
+};
+
+// Create a large message (512KB)
+function createLargeMessage(iteration) {
+    const size = 512 * 1024; // 512KB
+    const data = {
+        iteration: iteration,
+        timestamp: new Date().toISOString(),
+        // Large payload - mostly the same content
+        payload: 'X'.repeat(size - 100) + `_ITERATION_${iteration}`
+    };
+    return JSON.stringify(data);
+}
+
+// Send a batch of identical messages
+async function sendBatchMessages() {
+    console.log('Sending batch of 5 identical 512KB messages...');
+
+    const messages = [];
+    for (let i = 0; i < 5; i++) {
+        messages.push({
+            name: `large-event-${i}`,
+            channel: config.channel,
+            data: createLargeMessage(1) // Same content for all
+        });
+    }
+
+    const options = {
+        hostname: config.host,
+        port: config.port,
+        path: '/trigger-batch',
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    };
+
+    return new Promise((resolve, reject) => {
+        const req = http.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                console.log(`Response: ${res.statusCode}`);
+                if (res.statusCode === 200) {
+                    console.log('Batch messages sent successfully');
+                    resolve();
+                } else {
+                    console.log('Response body:', data);
+                    reject(new Error(`Failed with status ${res.statusCode}`));
+                }
+            });
+        });
+
+        req.on('error', reject);
+        req.write(JSON.stringify({ events: messages }));
+        req.end();
+    });
+}
+
+// Send sequential messages
+async function sendSequentialMessages() {
+    console.log('Sending 5 sequential identical 512KB messages...');
+
+    for (let i = 0; i < 5; i++) {
+        const options = {
+            hostname: config.host,
+            port: config.port,
+            path: '/trigger',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        };
+
+        await new Promise((resolve, reject) => {
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    if (res.statusCode === 200) {
+                        console.log(`  Message ${i+1} sent successfully`);
+                        resolve();
+                    } else {
+                        reject(new Error(`Failed with status ${res.statusCode}`));
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.write(JSON.stringify({
+                channel: config.channel,
+                event: `large-event-seq-${i}`,
+                data: createLargeMessage(1) // Same content for all
+            }));
+            req.end();
+        });
+
+        // Small delay between messages
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+}
+
+// Main test
+async function runTest() {
+    console.log('Delta Compression Test');
+    console.log('======================');
+    console.log('Make sure you have:');
+    console.log('1. Sockudo running on port 6001');
+    console.log('2. Test server running on port 3000');
+    console.log('3. Browser open at http://localhost:3000');
+    console.log('4. Delta compression enabled in the browser');
+    console.log('');
+
+    try {
+        // Test sequential messages (should work)
+        await sendSequentialMessages();
+        console.log('✓ Sequential messages test completed\n');
+
+        // Wait a bit
+        await new Promise(resolve => setTimeout(resolve, 2000));
+
+        // Test batch messages (known issue - will likely fail with delta)
+        console.log('Testing batch messages (known limitation with delta compression)...');
+        await sendBatchMessages();
+        console.log('✓ Batch messages test completed\n');
+
+        console.log('Test completed! Check the browser console for results.');
+        console.log('Expected behavior:');
+        console.log('- Sequential messages: Should show high compression ratio (~95-99%)');
+        console.log('- Batch messages: May show "bad checksum" errors (known limitation)');
+    } catch (error) {
+        console.error('Test failed:', error.message);
+        process.exit(1);
+    }
+}
+
+// Run the test
+runTest();

package/node.js

@@ -0,0 +1 @@
+module.exports = require('./dist/node/pusher');

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@cendarsoss/pusher-js",
+  "version": "8.4.11",
+  "description": "Pusher Channels JavaScript library for browsers, React Native, NodeJS and web workers",
+  "types": "index.d.ts",
+  "main": "dist/node/pusher.js",
+  "module": "dist/web/pusher.mjs",
+  "browser": "dist/web/pusher.js",
+  "react-native": "dist/react-native/pusher.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./dist/web/pusher.mjs",
+      "require": "./dist/node/pusher.js",
+      "default": "./dist/web/pusher.js"
+    },
+    "./filter": {
+      "types": "./types/src/core/channels/filter.d.ts",
+      "import": "./dist/web/filter.mjs",
+      "require": "./dist/node/filter.js",
+      "default": "./dist/web/filter.mjs"
+    }
+  },
+  "scripts": {
+    "build": "vite build && vite build --config vite.config.node.js",
+    "build:web": "vite build",
+    "build:node": "vite build --config vite.config.node.js",
+    "build:watch": "vite build --watch",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "format": "prettier --config .prettierrc --write 'src/**/*.ts' 'webpack/**/*.js'",
+    "check-format": "prettier --config .prettierrc --check 'src/**/*.ts' 'webpack/**/*.js'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pusher/pusher-js.git"
+  },
+  "keywords": [
+    "pusher",
+    "client",
+    "websocket",
+    "http",
+    "fallback",
+    "isomorphic",
+    "events",
+    "pubsub"
+  ],
+  "author": "Pusher",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pusher/pusher-js"
+  },
+  "homepage": "https://github.com/pusher/pusher-js",
+  "devDependencies": {
+    "@react-native-community/netinfo": "^5.9.7",
+    "@stablelib/base64": "^1.0.0",
+    "@stablelib/utf8": "^1.0.0",
+    "@types/express-serve-static-core": "4.17.28",
+    "@types/node": "^20.3.0",
+    "@vitejs/plugin-legacy": "^7.2.1",
+    "buffer": "^5.6.0",
+    "faye-websocket": "^0.11.3",
+    "fetch-mock": "git+https://git@github.com/jpatel531/fetch-mock.git",
+    "isomorphic-fetch": "^3.0.0",
+    "jasmine": "^4.5.0",
+    "jasmine-spec-reporter": "^7.0.0",
+    "karma": "^6.4.4",
+    "karma-browserstack-launcher": "^1.6.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-firefox-launcher": "^2.1.3",
+    "karma-jasmine": "^4.0.1",
+    "karma-jasmine-web-worker": "git+https://git@github.com/pusher/karma-jasmine-web-worker.git#jasmine_3",
+    "karma-opera-launcher": "^1.0.0",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-spec-reporter": "0.0.32",
+    "karma-verbose-reporter": "0.0.6",
+    "karma-webpack": "^4.0.2",
+    "prettier": "^3.4.2",
+    "source-map-loader": "^1.1.3",
+    "ts-loader": "^6.0.4",
+    "typescript": "^5.1.3",
+    "uglify-js": "^2.6.2",
+    "vite": "^7.2.7",
+    "webpack": "^4.46.0",
+    "webpack-cli": "^3.3.12",
+    "webpack-dev-server": "^4.11.1",
+    "webpack-merge": "^5.8.0",
+    "xmlhttprequest": "^1.8.0"
+  },
+  "dependencies": {
+    "@ably/vcdiff-decoder": "^1.0.6",
+    "fossil-delta": "^2.0.0",
+    "tweetnacl": "^1.0.3"
+  }
+}

package/pusher-with-encryption/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/web/pusher-with-encryption');

package/react-native/index.d.ts

@@ -0,0 +1,29 @@
+export {
+  DeprecatedAuthOptions,
+  ChannelAuthorizerGenerator
+} from '../types/src/core/auth/deprecated_channel_authorizer';
+export {
+  UserAuthenticationOptions,
+  ChannelAuthorizationOptions,
+  ChannelAuthorizationHandler,
+  UserAuthenticationHandler,
+  ChannelAuthorizationCallback,
+  UserAuthenticationCallback
+} from '../types/src/core/auth/options';
+export { Options } from '../types/src/core/options';
+
+export { default as Channel } from '../types/src/core/channels/channel';
+export { default as PresenceChannel } from '../types/src/core/channels/presence_channel';
+export { default as Members } from '../types/src/core/channels/members';
+export { default as Runtime } from '../types/src/runtimes/interface';
+export { default as ConnectionManager } from '../types/src/core/connection/connection_manager';
+
+export { default } from '../types/src/core/pusher';
+
+// The following types are provided for backward compatibility
+export {
+  DeprecatedAuthOptions as AuthOptions,
+  DeprecatedChannelAuthorizer as Authorizer,
+  ChannelAuthorizerGenerator as AuthorizerGenerator
+} from '../types/src/core/auth/deprecated_channel_authorizer';
+export { ChannelAuthorizationCallback as AuthorizerCallback } from '../types/src/core/auth/options';

package/react-native/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/react-native/pusher');

package/spec/config/jasmine/helpers/reporter.js

@@ -0,0 +1,14 @@
+const SpecReporter = require('jasmine-spec-reporter').SpecReporter;
+
+jasmine.getEnv().clearReporters();
+
+jasmine.getEnv().addReporter(
+  new SpecReporter({
+    spec: {
+      displayPending: true
+    },
+    summary: {
+      displayDuration: false
+    }
+  })
+);

package/spec/config/jasmine/integration.json

@@ -0,0 +1,13 @@
+{
+  "spec_dir": "./tmp/node_integration",
+  "spec_files": [
+    "**/*spec.js"
+  ],
+  "helpers": [
+    "../../spec/config/jasmine/helpers/**/*.js"
+  ],
+  "failSpecWithNoExpectations": false,
+  "stopSpecOnExpectationFailure": false,
+  "stopOnSpecFailure": false,
+  "random": false
+}

package/spec/config/jasmine/unit.json

@@ -0,0 +1,13 @@
+{
+  "spec_dir": "./tmp/node_unit",
+  "spec_files": [
+    "**/*spec.js"
+  ],
+  "helpers": [
+    "../../spec/config/jasmine/helpers/**/*.js"
+  ],
+  "failSpecWithNoExpectations": false,
+  "stopSpecOnExpectationFailure": false,
+  "stopOnSpecFailure": false,
+  "random": false
+}

package/spec/config/jasmine/webpack.integration.js

@@ -0,0 +1,33 @@
+const { merge } = require('webpack-merge');
+const path = require('path');
+const baseConfig = require('../../../webpack/config.node');
+
+module.exports = merge({}, baseConfig, {
+  entry: {
+    pusher: path.join(
+      __dirname,
+      "..",
+      "..",
+      "javascripts",
+      "integration",
+      "index.node"
+    )
+  },
+  output: {
+    filename: "integration_tests_spec.js",
+    path: path.join(__dirname, "..", "..", "..", "tmp", "node_integration"),
+    libraryTarget: "var"
+  },
+  resolve: {
+    modules: ['spec/javascripts/helpers'],
+    alias: {
+      pusher_integration: 'core/pusher.js',
+      integration: 'node/integration',
+      'dom/dependencies': 'node/mock-dom-dependencies',
+      'dom/dependency_loader': 'node/mock-dom-dependencies'
+    },
+  },
+  externals: {
+    testenv: "'node'"
+  }
+});