@rivium/chat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rivium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# RiviumChat Node.js SDK
+
+Server-side SDK for RiviumChat. Manage chat rooms, messages, reactions, pins, webhooks, and push notification templates from your Node.js backend.
+
+> **Server-side only.** This SDK requires a server secret and must never be used in client-side applications. The server secret can be extracted from client apps.
+
+## Features
+
+- Room management (create, find, list, add participants)
+- Message operations (send, edit, delete, search, mentions)
+- Read receipts and unread counts
+- Emoji reactions
+- Message pinning
+- Webhook configuration
+- Push notification templates (via Rivium Push)
+- Centrifugo connection token generation
+- Zero runtime dependencies — uses native Node.js `http`/`https`
+- TypeScript declarations included
+
+## Installation
+
+```bash
+npm install @rivium/chat
+```
+
+## Quick Start
+
+```typescript
+import { RiviumChat } from '@rivium/chat';
+
+const riviumChat = new RiviumChat({
+  apiKey: 'YOUR_API_KEY',
+  serverSecret: 'YOUR_SERVER_SECRET',
+});
+```
+
+### Create a Room
+
+```typescript
+const room = await riviumChat.rooms.findOrCreate({
+  externalId: 'order-123',
+  participants: [
+    { externalUserId: 'user-1', displayName: 'Alice', role: 'member' },
+    { externalUserId: 'user-2', displayName: 'Bob', role: 'member' },
+  ],
+});
+```
+
+### Send a Message
+
+```typescript
+const message = await riviumChat.messages.send(room.id, {
+  senderUserId: 'user-1',
+  content: 'Hello from the server!',
+});
+```
+
+### Get Message History
+
+```typescript
+const { messages, hasMore } = await riviumChat.messages.getHistory(room.id, {
+  userId: 'user-1',
+  limit: 50,
+});
+```
+
+### Mark as Read
+
+```typescript
+await riviumChat.messages.markAsRead(room.id, 'user-1');
+```
+
+### Unread Counts
+
+```typescript
+const summary = await riviumChat.rooms.getUnreadSummary('user-1');
+// { totalUnread: 5, rooms: [{ roomId, externalId, unreadCount }] }
+```
+
+## API Reference
+
+### Rooms
+
+```typescript
+riviumChat.rooms.create(options)                    // Create a room
+riviumChat.rooms.findOrCreate(options)               // Find or create by externalId
+riviumChat.rooms.get(roomId)                         // Get room by ID
+riviumChat.rooms.getByExternalId(externalId)          // Get room by external ID
+riviumChat.rooms.list(userId)                        // List rooms for a user
+riviumChat.rooms.addParticipant(roomId, options)      // Add participant to room
+riviumChat.rooms.getUnreadSummary(userId)             // Get unread counts
+```
+
+### Messages
+
+```typescript
+riviumChat.messages.send(roomId, options)             // Send a message
+riviumChat.messages.getHistory(roomId, options)        // Get paginated history
+riviumChat.messages.markAsRead(roomId, userId)         // Mark messages as read
+riviumChat.messages.edit(messageId, userId, content)   // Edit a message
+riviumChat.messages.delete(messageId, userId)          // Delete a message
+riviumChat.messages.search(roomId, options)            // Search messages
+riviumChat.messages.getMentions(roomId, options)        // Get @mentions
+```
+
+### Reactions
+
+```typescript
+riviumChat.reactions.add(messageId, userId, emoji)     // Add reaction
+riviumChat.reactions.remove(messageId, userId, emoji)   // Remove reaction
+riviumChat.reactions.list(messageId)                    // List reactions
+```
+
+### Pins
+
+```typescript
+riviumChat.pins.pin(messageId, userId)                 // Pin a message
+riviumChat.pins.unpin(messageId, userId)                // Unpin a message
+riviumChat.pins.list(roomId)                           // List pinned messages
+```
+
+### Webhooks
+
+```typescript
+riviumChat.webhooks.get()                              // Get webhook config
+riviumChat.webhooks.setWebhook({ url, secret? })        // Set webhook URL
+riviumChat.webhooks.removeWebhook()                     // Remove webhook
+riviumChat.webhooks.setPushTemplate(templateId)          // Set push template
+riviumChat.webhooks.removePushTemplate()                 // Remove push template
+riviumChat.webhooks.setPushTemplates(templates)           // Per-event push templates
+riviumChat.webhooks.removePushTemplates()                 // Remove per-event templates
+```
+
+### Tokens
+
+```typescript
+riviumChat.tokens.getConnectionToken({ userId, info? })  // Get Centrifugo token
+```
+
+## Push Notifications
+
+Configure push notifications for offline users via [Rivium Push](https://rivium.co/cloud/rivium-push):
+
+```typescript
+// Use a Rivium Push template
+await riviumChat.webhooks.setPushTemplate('your-template-id');
+
+// Or use per-event inline templates
+await riviumChat.webhooks.setPushTemplates({
+  new_message: {
+    title: '{{senderName}}',
+    body: '{{messagePreview}}',
+  },
+  mention: {
+    title: '{{senderName}} mentioned you',
+    body: '{{messagePreview}}',
+  },
+});
+```
+
+## Links
+
+- [Rivium Chat](https://rivium.co/cloud/rivium-chat) - Learn more about Rivium Chat
+- [Documentation](https://rivium.co/cloud/rivium-chat/docs/quick-start) - Full documentation and guides
+- [Rivium Console](https://console.rivium.co) - Manage your chat rooms
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+import { RiviumChatConfig } from './types';
+export declare class HttpClient {
+    private apiKey;
+    private serverSecret;
+    private baseUrl;
+    constructor(config: RiviumChatConfig);
+    request<T>(method: string, path: string, body?: any, query?: Record<string, any>): Promise<T>;
+    get<T>(path: string, query?: Record<string, any>): Promise<T>;
+    post<T>(path: string, body?: any, query?: Record<string, any>): Promise<T>;
+    put<T>(path: string, body?: any, query?: Record<string, any>): Promise<T>;
+    delete<T>(path: string, body?: any, query?: Record<string, any>): Promise<T>;
+}
+export declare class RiviumChatError extends Error {
+    statusCode: number;
+    response: any;
+    constructor(message: string, statusCode: number, response: any);
+}

package/dist/client.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiviumChatError = exports.HttpClient = void 0;
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const BASE_URL = 'https://chat.rivium.co';
+class HttpClient {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('RiviumChat: apiKey is required');
+        }
+        if (!config.serverSecret) {
+            throw new Error('RiviumChat: serverSecret is required');
+        }
+        this.apiKey = config.apiKey;
+        this.serverSecret = config.serverSecret;
+        this.baseUrl = BASE_URL;
+    }
+    async request(method, path, body, query) {
+        const url = new URL(path, this.baseUrl);
+        if (query) {
+            for (const [k, v] of Object.entries(query)) {
+                if (v !== undefined && v !== null) {
+                    url.searchParams.set(k, String(v));
+                }
+            }
+        }
+        const payload = body ? JSON.stringify(body) : undefined;
+        const isHttps = url.protocol === 'https:';
+        const lib = isHttps ? https_1.default : http_1.default;
+        const headers = {
+            'x-api-key': this.apiKey,
+            'x-server-secret': this.serverSecret,
+            'Content-Type': 'application/json',
+        };
+        if (payload) {
+            headers['Content-Length'] = Buffer.byteLength(payload);
+        }
+        return new Promise((resolve, reject) => {
+            const req = lib.request(url, {
+                method,
+                headers,
+            }, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => {
+                    const statusCode = res.statusCode || 0;
+                    let parsed;
+                    try {
+                        parsed = data ? JSON.parse(data) : {};
+                    }
+                    catch {
+                        parsed = { message: data };
+                    }
+                    if (statusCode >= 200 && statusCode < 300) {
+                        resolve(parsed);
+                    }
+                    else {
+                        const err = new RiviumChatError(parsed.message || `Request failed with status ${statusCode}`, statusCode, parsed);
+                        reject(err);
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (payload)
+                req.write(payload);
+            req.end();
+        });
+    }
+    get(path, query) {
+        return this.request('GET', path, undefined, query);
+    }
+    post(path, body, query) {
+        return this.request('POST', path, body, query);
+    }
+    put(path, body, query) {
+        return this.request('PUT', path, body, query);
+    }
+    delete(path, body, query) {
+        return this.request('DELETE', path, body, query);
+    }
+}
+exports.HttpClient = HttpClient;
+class RiviumChatError extends Error {
+    constructor(message, statusCode, response) {
+        super(message);
+        this.name = 'RiviumChatError';
+        this.statusCode = statusCode;
+        this.response = response;
+    }
+}
+exports.RiviumChatError = RiviumChatError;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { Rooms } from './modules/rooms';
+import { Messages } from './modules/messages';
+import { Reactions } from './modules/reactions';
+import { Pins } from './modules/pins';
+import { Webhooks } from './modules/webhooks';
+import { Tokens } from './modules/tokens';
+import { RiviumChatConfig } from './types';
+export declare class RiviumChat {
+    private client;
+    /** Room management */
+    rooms: Rooms;
+    /** Message operations */
+    messages: Messages;
+    /** Message reactions */
+    reactions: Reactions;
+    /** Pinned messages */
+    pins: Pins;
+    /** Webhook & push configuration */
+    webhooks: Webhooks;
+    /** Centrifugo connection tokens */
+    tokens: Tokens;
+    constructor(config: RiviumChatConfig);
+}
+export { RiviumChatError } from './client';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiviumChatError = exports.RiviumChat = void 0;
+const client_1 = require("./client");
+const rooms_1 = require("./modules/rooms");
+const messages_1 = require("./modules/messages");
+const reactions_1 = require("./modules/reactions");
+const pins_1 = require("./modules/pins");
+const webhooks_1 = require("./modules/webhooks");
+const tokens_1 = require("./modules/tokens");
+class RiviumChat {
+    constructor(config) {
+        this.client = new client_1.HttpClient(config);
+        this.rooms = new rooms_1.Rooms(this.client);
+        this.messages = new messages_1.Messages(this.client);
+        this.reactions = new reactions_1.Reactions(this.client);
+        this.pins = new pins_1.Pins(this.client);
+        this.webhooks = new webhooks_1.Webhooks(this.client);
+        this.tokens = new tokens_1.Tokens(this.client);
+    }
+}
+exports.RiviumChat = RiviumChat;
+var client_2 = require("./client");
+Object.defineProperty(exports, "RiviumChatError", { enumerable: true, get: function () { return client_2.RiviumChatError; } });
+__exportStar(require("./types"), exports);

package/dist/modules/messages.d.ts

@@ -0,0 +1,24 @@
+import { HttpClient } from '../client';
+import { Message, PaginatedMessages, SendMessageOptions, GetHistoryOptions, SearchResult, SearchMessagesOptions, GetMentionsOptions, Mention } from '../types';
+export declare class Messages {
+    private client;
+    constructor(client: HttpClient);
+    /** Send a message to a room. */
+    send(roomId: string, options: SendMessageOptions): Promise<Message>;
+    /** Get message history for a room (paginated). */
+    getHistory(roomId: string, options: GetHistoryOptions): Promise<PaginatedMessages>;
+    /** Mark messages as read in a room for a user. */
+    markAsRead(roomId: string, userId: string): Promise<{
+        success: boolean;
+    }>;
+    /** Edit a message. */
+    edit(messageId: string, userId: string, content: string): Promise<Message>;
+    /** Delete a message. */
+    delete(messageId: string, userId: string): Promise<{
+        success: boolean;
+    }>;
+    /** Search messages in a room. */
+    search(roomId: string, options: SearchMessagesOptions): Promise<SearchResult>;
+    /** Get mentions for a user in a room. */
+    getMentions(roomId: string, options: GetMentionsOptions): Promise<Mention[]>;
+}

package/dist/modules/messages.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Messages = void 0;
+class Messages {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Send a message to a room. */
+    async send(roomId, options) {
+        return this.client.post(`/api/v1/rooms/${roomId}/messages`, options);
+    }
+    /** Get message history for a room (paginated). */
+    async getHistory(roomId, options) {
+        return this.client.get(`/api/v1/rooms/${roomId}/messages`, {
+            userId: options.userId,
+            limit: options.limit,
+            before: options.before,
+        });
+    }
+    /** Mark messages as read in a room for a user. */
+    async markAsRead(roomId, userId) {
+        return this.client.post(`/api/v1/rooms/${roomId}/read`, { userId });
+    }
+    /** Edit a message. */
+    async edit(messageId, userId, content) {
+        return this.client.put(`/api/v1/messages/${messageId}`, { userId, content });
+    }
+    /** Delete a message. */
+    async delete(messageId, userId) {
+        return this.client.delete(`/api/v1/messages/${messageId}`, undefined, { userId });
+    }
+    /** Search messages in a room. */
+    async search(roomId, options) {
+        return this.client.get(`/api/v1/rooms/${roomId}/messages/search`, {
+            q: options.q,
+            userId: options.userId,
+            limit: options.limit,
+            offset: options.offset,
+        });
+    }
+    /** Get mentions for a user in a room. */
+    async getMentions(roomId, options) {
+        return this.client.get(`/api/v1/rooms/${roomId}/mentions`, {
+            userId: options.userId,
+            limit: options.limit,
+        });
+    }
+}
+exports.Messages = Messages;

package/dist/modules/pins.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from '../client';
+import { Message } from '../types';
+export declare class Pins {
+    private client;
+    constructor(client: HttpClient);
+    /** Pin a message. */
+    pin(messageId: string, userId: string): Promise<Message>;
+    /** Unpin a message. */
+    unpin(messageId: string, userId: string): Promise<{
+        success: boolean;
+    }>;
+    /** Get all pinned messages in a room. */
+    list(roomId: string): Promise<Message[]>;
+}

package/dist/modules/pins.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pins = void 0;
+class Pins {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Pin a message. */
+    async pin(messageId, userId) {
+        return this.client.post(`/api/v1/messages/${messageId}/pin`, { userId });
+    }
+    /** Unpin a message. */
+    async unpin(messageId, userId) {
+        return this.client.delete(`/api/v1/messages/${messageId}/pin`, { userId });
+    }
+    /** Get all pinned messages in a room. */
+    async list(roomId) {
+        return this.client.get(`/api/v1/rooms/${roomId}/pinned`);
+    }
+}
+exports.Pins = Pins;

package/dist/modules/reactions.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from '../client';
+import { Reaction } from '../types';
+export declare class Reactions {
+    private client;
+    constructor(client: HttpClient);
+    /** Add a reaction to a message. */
+    add(messageId: string, userId: string, emoji: string): Promise<Reaction>;
+    /** Remove a reaction from a message. */
+    remove(messageId: string, userId: string, emoji: string): Promise<{
+        success: boolean;
+    }>;
+    /** Get all reactions for a message. */
+    list(messageId: string): Promise<Reaction[]>;
+}

package/dist/modules/reactions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reactions = void 0;
+class Reactions {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Add a reaction to a message. */
+    async add(messageId, userId, emoji) {
+        return this.client.post(`/api/v1/messages/${messageId}/reactions`, { userId, emoji });
+    }
+    /** Remove a reaction from a message. */
+    async remove(messageId, userId, emoji) {
+        return this.client.delete(`/api/v1/messages/${messageId}/reactions`, { userId, emoji });
+    }
+    /** Get all reactions for a message. */
+    async list(messageId) {
+        return this.client.get(`/api/v1/messages/${messageId}/reactions`);
+    }
+}
+exports.Reactions = Reactions;

package/dist/modules/rooms.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient } from '../client';
+import { Room, CreateRoomOptions, AddParticipantOptions, Participant, UnreadSummary } from '../types';
+export declare class Rooms {
+    private client;
+    constructor(client: HttpClient);
+    /** Create a new chat room. */
+    create(options: CreateRoomOptions): Promise<Room>;
+    /** Find existing room by externalId or create a new one. */
+    findOrCreate(options: CreateRoomOptions): Promise<Room>;
+    /** Get room by external ID. */
+    getByExternalId(externalId: string): Promise<Room>;
+    /** List rooms for a user. */
+    list(userId: string): Promise<Room[]>;
+    /** Get room by ID. */
+    get(id: string): Promise<Room>;
+    /** Get unread counts across all rooms for a user. */
+    getUnreadSummary(userId: string): Promise<UnreadSummary>;
+    /** Add a participant to a room. */
+    addParticipant(roomId: string, options: AddParticipantOptions): Promise<Participant>;
+}

package/dist/modules/rooms.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rooms = void 0;
+class Rooms {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Create a new chat room. */
+    async create(options) {
+        return this.client.post('/api/v1/rooms', options);
+    }
+    /** Find existing room by externalId or create a new one. */
+    async findOrCreate(options) {
+        return this.client.post('/api/v1/rooms/find-or-create', options);
+    }
+    /** Get room by external ID. */
+    async getByExternalId(externalId) {
+        return this.client.get(`/api/v1/rooms/by-external-id/${encodeURIComponent(externalId)}`);
+    }
+    /** List rooms for a user. */
+    async list(userId) {
+        return this.client.get('/api/v1/rooms', { userId });
+    }
+    /** Get room by ID. */
+    async get(id) {
+        return this.client.get(`/api/v1/rooms/${id}`);
+    }
+    /** Get unread counts across all rooms for a user. */
+    async getUnreadSummary(userId) {
+        return this.client.get('/api/v1/rooms/unread-summary', { userId });
+    }
+    /** Add a participant to a room. */
+    async addParticipant(roomId, options) {
+        return this.client.post(`/api/v1/rooms/${roomId}/participants`, options);
+    }
+}
+exports.Rooms = Rooms;

package/dist/modules/tokens.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '../client';
+import { GetTokenOptions } from '../types';
+export declare class Tokens {
+    private client;
+    constructor(client: HttpClient);
+    /** Get a Centrifugo connection token for a user. */
+    getConnectionToken(options: GetTokenOptions): Promise<{
+        token: string;
+    }>;
+}

package/dist/modules/tokens.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tokens = void 0;
+class Tokens {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Get a Centrifugo connection token for a user. */
+    async getConnectionToken(options) {
+        return this.client.post('/api/v1/centrifugo/token', options);
+    }
+}
+exports.Tokens = Tokens;

package/dist/modules/webhooks.d.ts

@@ -0,0 +1,35 @@
+import { HttpClient } from '../client';
+import { WebhookConfig, SetWebhookOptions, PushTemplates } from '../types';
+export declare class Webhooks {
+    private client;
+    constructor(client: HttpClient);
+    /** Get current webhook and push configuration. */
+    get(): Promise<WebhookConfig>;
+    /** Set webhook URL (and optional secret for HMAC-SHA256 signature verification). */
+    setWebhook(options: SetWebhookOptions): Promise<{
+        success: boolean;
+        webhookUrl: string;
+    }>;
+    /** Remove webhook configuration. */
+    removeWebhook(): Promise<{
+        success: boolean;
+    }>;
+    /** Set Pushino template ID for offline push notifications. */
+    setPushTemplate(pushTemplateId: string): Promise<{
+        success: boolean;
+        pushTemplateId: string;
+    }>;
+    /** Remove push notification template configuration. */
+    removePushTemplate(): Promise<{
+        success: boolean;
+    }>;
+    /** Set per-event push notification config (template ID, inline title/body, or skip). */
+    setPushTemplates(templates: PushTemplates): Promise<{
+        success: boolean;
+        pushTemplates: PushTemplates;
+    }>;
+    /** Remove per-event push template configuration. */
+    removePushTemplates(): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/modules/webhooks.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhooks = void 0;
+class Webhooks {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Get current webhook and push configuration. */
+    async get() {
+        return this.client.get('/api/v1/webhook');
+    }
+    /** Set webhook URL (and optional secret for HMAC-SHA256 signature verification). */
+    async setWebhook(options) {
+        return this.client.put('/api/v1/webhook', options);
+    }
+    /** Remove webhook configuration. */
+    async removeWebhook() {
+        return this.client.delete('/api/v1/webhook');
+    }
+    /** Set Pushino template ID for offline push notifications. */
+    async setPushTemplate(pushTemplateId) {
+        return this.client.put('/api/v1/webhook/push', { pushTemplateId });
+    }
+    /** Remove push notification template configuration. */
+    async removePushTemplate() {
+        return this.client.delete('/api/v1/webhook/push');
+    }
+    /** Set per-event push notification config (template ID, inline title/body, or skip). */
+    async setPushTemplates(templates) {
+        return this.client.put('/api/v1/webhook/push-templates', templates);
+    }
+    /** Remove per-event push template configuration. */
+    async removePushTemplates() {
+        return this.client.delete('/api/v1/webhook/push-templates');
+    }
+}
+exports.Webhooks = Webhooks;

package/dist/types.d.ts

@@ -0,0 +1,162 @@
+export interface RiviumChatConfig {
+    /** Your Rivium API key */
+    apiKey: string;
+    /** Your Rivium server secret — required for server-side operations */
+    serverSecret: string;
+}
+export type RoomType = 'direct' | 'group';
+export type ParticipantRole = 'admin' | 'member';
+export type MessageType = 'text' | 'image' | 'file' | 'system';
+export interface Attachment {
+    url: string;
+    mimeType: string;
+    name: string;
+    size: number;
+}
+export interface Participant {
+    id: string;
+    roomId: string;
+    externalUserId: string;
+    displayName?: string;
+    locale?: string;
+    role: ParticipantRole;
+    lastReadAt?: string;
+    joinedAt: string;
+}
+export interface Room {
+    id: string;
+    appId: string;
+    type: RoomType;
+    externalId?: string;
+    name?: string;
+    metadata?: Record<string, any>;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    participants?: Participant[];
+}
+export interface Message {
+    id: string;
+    roomId: string;
+    senderUserId: string;
+    type: MessageType;
+    content: string;
+    attachments?: Attachment[];
+    metadata?: Record<string, any>;
+    replyToId?: string;
+    replyTo?: Message;
+    isDeleted: boolean;
+    isEdited: boolean;
+    editedAt?: string;
+    editHistory?: {
+        content: string;
+        editedAt: string;
+    }[];
+    isPinned: boolean;
+    pinnedAt?: string;
+    pinnedBy?: string;
+    createdAt: string;
+    reactions?: Reaction[];
+}
+export interface Reaction {
+    id: string;
+    messageId: string;
+    userId: string;
+    emoji: string;
+    createdAt: string;
+}
+export interface Mention {
+    id: string;
+    messageId: string;
+    mentionedUserId: string;
+    roomId: string;
+    createdAt: string;
+    message: Message;
+}
+export interface PaginatedMessages {
+    messages: Message[];
+    hasMore: boolean;
+}
+export interface SearchResult {
+    messages: Message[];
+    total: number;
+}
+export interface RoomUnread {
+    roomId: string;
+    unreadCount: number;
+}
+export interface UnreadSummary {
+    totalUnread: number;
+    rooms: RoomUnread[];
+}
+export interface EventPushConfig {
+    templateId?: string;
+    title?: string;
+    body?: string;
+    skip?: boolean;
+}
+export interface PushTemplates {
+    new_message?: EventPushConfig;
+    mention?: EventPushConfig;
+    reaction?: EventPushConfig;
+    room_created?: EventPushConfig;
+    participant_joined?: EventPushConfig;
+    file_shared?: EventPushConfig;
+    message_pinned?: EventPushConfig;
+}
+export interface WebhookConfig {
+    webhookUrl: string | null;
+    hasSecret: boolean;
+    pushTemplateId: string | null;
+    pushTemplates: PushTemplates | null;
+}
+export interface ParticipantInput {
+    externalUserId: string;
+    displayName?: string;
+    locale?: string;
+    role?: ParticipantRole;
+}
+export interface CreateRoomOptions {
+    type?: RoomType;
+    externalId?: string;
+    name?: string;
+    participants: ParticipantInput[];
+    metadata?: Record<string, any>;
+}
+export interface AddParticipantOptions {
+    externalUserId: string;
+    displayName?: string;
+    locale?: string;
+    role?: ParticipantRole;
+}
+export interface SendMessageOptions {
+    senderUserId: string;
+    content: string;
+    type?: MessageType;
+    attachments?: Attachment[];
+    metadata?: Record<string, any>;
+    replyToId?: string;
+}
+export interface GetHistoryOptions {
+    userId: string;
+    limit?: number;
+    before?: string;
+}
+export interface SearchMessagesOptions {
+    q: string;
+    userId: string;
+    limit?: number;
+    offset?: number;
+}
+export interface GetMentionsOptions {
+    userId: string;
+    limit?: number;
+}
+export interface SetWebhookOptions {
+    url: string;
+    secret?: string;
+}
+export interface GetTokenOptions {
+    userId: string;
+    info?: Record<string, any>;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// ─── Configuration ───────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@rivium/chat",
+  "version": "0.1.0",
+  "description": "RiviumChat Node.js SDK — server-side chat rooms, messages, reactions, pins, and webhooks",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "rivium",
+    "rivium-chat",
+    "chat",
+    "messaging",
+    "rooms",
+    "realtime"
+  ],
+  "author": "Rivium <support@rivium.co>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rivium-co/rivium-chat-nodejs-sdk.git"
+  },
+  "homepage": "https://rivium.co/cloud/rivium-chat",
+  "engines": {
+    "node": ">=16"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.0",
+    "typescript": "^5.9.3"
+  }
+}