Server SDK

npm install pingerchips-js-server

import PingerchipsServer from 'pingerchips-js-server';

const pc = new PingerchipsServer(appKey, appSecret, options);

await pc.trigger(channel, event, data);

await pc.trigger('announcements', 'new-post', { title: 'v2 released', url: '/blog/v2' });
await pc.trigger(`private-user-${userId}`, 'notification', { type: 'order-shipped' });

await pc.triggerBatch(['room-a', 'room-b', 'room-c'], 'update', { value: 42 });

pc.authenticate(socketId, channelName, userData?)

// private   caps: channel:subscribe:{channelName}
{ auth: "{appKey}.{payloadB64}.{sigB64}" }

// private with user data
{ auth: "{appKey}.{payloadB64}.{sigB64}", user_data: "{...json...}" }

// presence  caps: channel:subscribe:{channelName}, channel:presence:{channelName}
{ auth: "{appKey}.{payloadB64}.{sigB64}", channel_data: "{...json...}" }

pc.authorize(socketId, {
  channels: ['orders'],
  presence: ['lobby'],
  objects:  [{ type: 'order', key: 'order-42' }],
  threads:  ['thread-abc'],
}, clientId);
// → { auth }  — one fast-path token covering every listed grant

import express from 'express';
import PingerchipsServer from 'pingerchips-js-server';

const app = express();
app.use(express.json());
const pc = new PingerchipsServer(process.env.PINGERCHIPS_APP_KEY, process.env.PINGERCHIPS_APP_SECRET);

app.post('/pingerchips/auth', (req, res) => {
  const { socket_id, channel_name, auth_info } = req.body;

  const user = verifyUser(auth_info?.token);
  if (!user) return res.status(403).json({ error: 'Unauthorized' });

  // authorize this specific channel
  if (channel_name.startsWith('private-') && channel_name !== `private-user-${user.id}`) {
    return res.status(403).json({ error: 'Access denied' });
  }

  let userData = null;
  if (channel_name.startsWith('presence-')) {
    userData = { user_id: user.id, user_info: { name: user.name, avatar: user.avatarUrl } };
  }

  res.json(pc.authenticate(socket_id, channel_name, userData));
});

app.listen(3000);

// full client verb set for the thread
const token = await pc.authenticateChat(socketId, threadId, clientId);
// { auth: "<jwt>" }

// narrowed — read-only
await pc.authenticateChat(socketId, threadId, clientId, ['subscribe']);

// only if the user has no active connection
await pc.notify('user-123', { title: 'New message', body: 'Alice said hi' });

// always deliver
await pc.notify(
  'user-123',
  { title: 'Alert', body: 'Action required' },
  { trigger: 'always', data: { url: '/alerts' } },
);

// mobile
await pc.registerPushToken('user-123', {
  deviceId: 'device-abc',
  platform: 'fcm',           // 'fcm' | 'web_fcm' | 'apns' | 'web'
  token: 'FCM_TOKEN',
});

// web push
await pc.registerPushToken('user-123', {
  deviceId: 'browser-xyz',
  platform: 'web',
  endpoint: 'https://fcm.googleapis.com/...',
  p256dh: '...',
  auth: '...',
});

await pc.unregisterPushToken('user-123', 'device-abc');

const order = pc.object('order', 'order-42');
await order.set('status', 'shipped');           // X-App-Key / X-App-Secret headers

// browser subscription token
const { auth } = pc.authenticateObject(socketId, 'order', 'order-42');
// caps: object:read:order/order-42

import { channelConfig, durableChannelConfig, ephemeralChannelConfig } from 'pingerchips-js-server';

channelConfig({ durable: true, replay: true, maxReplayMessages: 500, ordering: 'strict' });
// → { durable, replay, max_replay_messages, ordering, flow_engine }

durableChannelConfig();    // L2: WAL + strict ordering + full replay
ephemeralChannelConfig();  // L0: no WAL, no replay, best-effort

import { PingerchipsServerChat } from 'pingerchips-js-server';

const chat = new PingerchipsServerChat(
  process.env.PINGERCHIPS_APP_KEY,
  process.env.PINGERCHIPS_APP_SECRET,
);

// threads
const thread = await chat.createThread({ title: 'Support #42', createdBy: 'user-1' });
await chat.assignBot(thread.id, 'support-bot');
await chat.resolveThread(thread.id);
await chat.archiveThread(thread.id);
await chat.handoffThread(thread.id, 'agent-99');

// participants
await chat.joinThread(thread.id, { userId: 'user-1', role: 'member' });
await chat.markRead(thread.id, participantId);

// messages
await chat.sendMessage(thread.id, { userId: 'user-1', content: { text: 'Hello!' } });
const msgs = await chat.listMessages(thread.id, { page: 1 });
await chat.editMessage(thread.id, msgs[0].id, { text: 'Hello, edited' });

const pc = new PingerchipsServer(APP_KEY, APP_SECRET, {
  mtls: {
    enabled: true,
    cert: '/path/to/client-cert.pem',   // path or PEM string
    key:  '/path/to/client-key.pem',
    ca:   '/path/to/ca-cert.pem',
    rejectUnauthorized: true,
  },
});

try {
  await pc.trigger('my-channel', 'my-event', { text: 'Hello' });
} catch (err) {
  // "channel must be a non-empty string"
  // "data payload must be 64KB or less"
  // "Failed to trigger event: 429 Too Many Requests - Rate limit exceeded"
  // "Request timeout after 10000ms"
}