jolt-js-api 1.0.0 → 1.1.8

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,30 @@
+name: Publish to NPM
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm instal
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm install
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/README.md

@@ -1,15 +1,15 @@
 # Jolt JavaScript API
 
-A JavaScript & Node.js client for the [Jolt](https://github.com/Jolt-Database/Jolt) in-memory messaging broker.
+[![npm version](https://badge.fury.io/js/jolt-js-api.svg)](https://www.npmjs.com/package/jolt-js-api) 
+[![npm downloads](https://img.shields.io/npm/dm/jolt-js-api.svg)](https://www.npmjs.com/package/jolt-js-api)
 
-## Features
+This repository is a JavaScript and Node.js client. This package provides direct access to the Jolt protocol, offering a lightweight, dependency-free interface for building real-time distributed applications, internal services, and event-driven systems.
 
-✅ Native Jolt broker protocol support  
-✅ Event-driven architecture (EventEmitter)  
-✅ Promise-based API available  
-✅ Simple pub/sub messaging  
-✅ No external dependencies (Node.js core only)  
-✅ TypeScript definitions included  
+## Overview
+
+The Jolt JavaScript API communicates with our Jolt broker using its native TCP protocol and newline-delimited JSON messaging format. The client exposes a Node.js EventEmitter interface and supports both callback-based and Promise-based usage.
+
+This module intentionally relies only on Node.js core libraries to ensure low overhead, portability, and minimal setup requirements. TypeScript definitions are included for typed development environments.
 
 ## Installation
 
@@ -17,50 +17,43 @@ A JavaScript & Node.js client for the [Jolt](https://github.com/Jolt-Database/Jo
 npm install jolt-js-api
 ```
 
-Or from source:
+Installation from source:
 
 ```bash
-git clone https://github.com/DevArqf/jolt-js-api.git
+git clone https://github.com/Jolt-Database/jolt-js-api.git
 cd jolt-js-api
 npm install
 ```
 
-## Quick Start
+## Usage Example
 
 ```javascript
 const JoltClient = require('jolt-js-api');
 
-// Create client
 const client = new JoltClient({
   host: '127.0.0.1',
   port: 8080
 });
 
-// Set up event handlers
-client.on('connected', () => console.log('Connected'));
-client.on('ok', () => console.log('✓ OK'));
-client.on('error', (error) => console.log('✗ Error:', error));
+client.on('connected', () => console.log('Connected to broker'));
 client.on('message', (topic, data) => console.log(`[${topic}] ${data}`));
-client.on('disconnected', () => console.log('Disconnected'));
+client.on('error', (error) => console.error('Error:', error));
 
-// Connect and use
 async function main() {
   await client.connect();
-  
+
   client.subscribe('chat.general');
   client.publish('chat.general', 'Hello, Jolt!');
   client.ping();
-  
-  // Keep running...
+
   await new Promise(resolve => setTimeout(resolve, 2000));
-  
   client.close();
 }
 
 main();
 ```
 
-## API Reference
+## API Summary
 
 ### Constructor
 
@@ -68,134 +61,99 @@ main();
 const client = new JoltClient(config);
 ```
 
-**Config Options:**
-- `host` (string): Broker host (default: '127.0.0.1')
-- `port` (number): Broker port (default: 8080)
+Configuration options:
 
-### Methods
+* **host**: Broker hostname (default: `127.0.0.1`)
+* **port**: Broker port (default: `8080`)
 
-#### Connection
-- `connect()` → Promise<void> - Connect to broker
-- `close()` → void - Close connection
-- `isConnected()` → boolean - Check connection status
+### Connection Methods
 
-#### Operations
-- `auth(username, password)` → void - Authenticate
-- `subscribe(topic)` → void - Subscribe to topic
-- `unsubscribe(topic)` → void - Unsubscribe from topic
-- `publish(topic, data)` → void - Publish message
-- `ping()` → void - Send ping
+* **connect()** – Establishes a connection to the broker.
+* **close()** – Closes the client connection.
+* **isConnected()** – Returns connection state.
 
-### Events
+### Messaging Methods
 
-```javascript
-client.on('connected', () => {})
-client.on('ok', (rawLine) => {})
-client.on('error', (errorMsg, rawLine) => {})
-client.on('message', (topic, data, rawLine) => {})
-client.on('disconnected', () => {})
-client.on('socketError', (err) => {})
-client.on('parseError', (err, line) => {})
-client.on('unknown', (data, line) => {})
-```
+* **auth(username, password)** – Performs broker authentication.
+* **subscribe(topic)** – Subscribes to a topic.
+* **unsubscribe(topic)** – Removes an existing subscription.
+* **publish(topic, data)** – Publishes a message to a topic.
+* **ping()** – Issues a protocol-level health check.
 
-## Examples
+### Event Interface
 
-### Simple Chat
+* **connected**
+* **ok**
+* **error**
+* **message**
+* **disconnected**
+* **socketError**
+* **parseError**
+* **unknown**
 
-```javascript
-const JoltClient = require('jolt-js-api');
+These events provide full visibility into the broker communication, parsing results, socket behavior, and message routing.
 
-const client = new JoltClient();
+## Additional Examples
 
-client.on('message', (topic, data) => {
-  console.log(`[${topic}] ${data}`);
-});
+### Simple Pub/Sub
 
+```javascript
 await client.connect();
 client.subscribe('chat.room1');
-client.publish('chat.room1', 'Hello everyone!');
+client.publish('chat.room1', 'Hello');
 ```
 
 ### Multiple Topics
 
 ```javascript
-const topics = ['news', 'sports', 'weather'];
+['news', 'sports', 'weather']
+  .forEach(t => client.subscribe(t));
 
-// Subscribe to all
-topics.forEach(topic => client.subscribe(topic));
-
-// Publish to each
-client.publish('news', 'Breaking news!');
-client.publish('sports', 'Score: 3-2');
-client.publish('weather', 'Sunny, 25°C');
+client.publish('news', 'Latest headline');
 ```
 
-### Promise-Based Operations
+### Promise-Based Wrapper Usage
 
 ```javascript
-const JoltClientWrapper = require('./examples/advanced-usage');
-
-const client = new JoltClientWrapper({ host: '127.0.0.1', port: 8080 });
-
 await client.connect();
 await client.subscribeAsync('chat.general');
-await client.publishAsync('chat.general', 'Hello!');
+await client.publishAsync('chat.general', 'Hello');
 ```
 
-### Error Handling
+### Error Handling Pattern
 
 ```javascript
-client.on('error', (error) => {
-  if (error.includes('auth')) {
-    console.error('Authentication failed!');
-  } else if (error.includes('unknown_topic')) {
-    console.error('Topic does not exist!');
-  } else {
-    console.error('Error:', error);
-  }
-});
-
-client.on('socketError', (err) => {
-  console.error('Socket error:', err);
-  // Implement reconnection logic
+client.on('error', (err) => {
+  console.error(err);
 });
 ```
 
 ## Testing
 
 ```bash
-# Run tests (broker must be running)
 npm test
-
-# Watch mode
 npm run test:watch
-
-# Run examples
 npm run example
 npm run example:advanced
 ```
 
-## Protocol
+A running Jolt broker instance is required for full test execution.
+
+## Protocol Notes
+
+Communication uses newline-delimited JSON over TCP.
 
-Jolt uses NDJSON (newline-delimited JSON) over TCP:
+Example request frames:
 
-### Commands
 ```json
 {"op": "auth", "user": "username", "pass": "password"}
-{"op": "sub", "topic": "channel"}
-{"op": "unsub", "topic": "channel"}
 {"op": "pub", "topic": "channel", "data": "message"}
-{"op": "ping"}
+{"op": "sub", "topic": "channel"}
 ```
 
-### Responses
+Example response frames:
+
 ```json
 {"ok": true}
-{"ok": false, "error": "error_message"}
 {"topic": "channel", "data": "message"}
-```
-
-## License
-
-MIT License - see LICENSE file for details
+```

package/package.json

@@ -1,33 +1,32 @@
 {
     "name": "jolt-js-api",
-    "version": "1.0.0",
+    "version": "1.1.8",
     "description": "JavaScript & Node.js client for the Jolt in-memory messaging broker",
     "main": "src/JoltClient.js",
     "scripts": {
-      "test": "jest",
-      "test:watch": "jest --watch",
-      "example": "node examples/simple-chat.js",
-      "example:advanced": "node examples/advanced-usage.js"
+        "example": "node examples/simple-chat.js",
+        "example:advanced": "node examples/advanced-usage.js"
     },
     "keywords": [
-      "jolt",
-      "messaging",
-      "broker",
-      "pubsub",
-      "real-time",
-      "tcp",
-      "ndjson"
+        "jolt",
+        "messaging",
+        "broker",
+        "pubsub",
+        "real-time",
+        "tcp",
+        "ndjson"
     ],
     "author": "DevArqf",
     "license": "MIT",
     "repository": {
-      "type": "git",
-      "url": "https://github.com/DevArqf/jolt-js-api"
+        "type": "git",
+        "url": "git://github.com/Jolt-Database/jolt-js-api"
     },
-    "devDependencies": {
-      "jest": "^29.0.0"
+    "homepage": "https://github.com/Jolt-Database/jolt-js-api#readme",
+    "bugs": {
+        "url": "https://github.com/Jolt-Database/jolt-js-api/issues"
     },
     "engines": {
-      "node": ">=14.0.0"
+        "node": ">=14.0.0"
     }
-  }
+}