hsync 0.30.2 → 0.32.0

package/package.json

@@ -1,13 +1,49 @@
 {
   "name": "hsync",
-  "version": "0.30.2",
+  "version": "0.32.0",
+  "type": "module",
   "description": "client for hsync-server",
-  "main": "hsync.js",
+  "main": "./hsync.js",
+  "exports": {
+    ".": {
+      "browser": {
+        "import": "./hsync-web.js"
+      },
+      "node": {
+        "import": "./hsync.js"
+      },
+      "default": "./hsync.js"
+    },
+    "./web": {
+      "import": "./hsync-web.js"
+    },
+    "./node": {
+      "import": "./hsync.js"
+    },
+    "./config": {
+      "import": "./config.js"
+    },
+    "./connection": {
+      "import": "./connection.js"
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "dev": "nodemon --inspect index.js",
     "start": "node index.js",
-    "build": "webpack && BUILD_MODE=production webpack"
+    "build": "webpack && BUILD_MODE=production webpack",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"**/*.js\"",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.js": [
+      "eslint --fix",
+      "prettier --write"
+    ]
   },
   "repository": {
     "type": "git",
@@ -25,7 +61,7 @@
     "tunnel"
   ],
   "browser": {
-    "./hsync": "./hsync-web"
+    "./hsync.js": "./hsync-web.js"
   },
   "bin": {
     "hsync": "./cli.js",
@@ -34,23 +70,30 @@
   "author": "Luis Montes",
   "license": "ISC",
   "dependencies": {
-    "b64id": "^1.0.0",
+    "b64id": "^1.1.1",
     "buffer": "^6.0.3",
-    "commander": "^10.0.0",
-    "debug": "^4.3.1",
-    "isomorphic-fetch": "^3.0.0",
-    "mqtt": "^4.2.6",
-    "mqtt-packet-web": "^8.2.0",
-    "net-web": "^0.2.0",
-    "precompiled-mqtt": "^4.3.14-beta",
-    "rawr": "^0.15.1"
+    "commander": "^14.0.2",
+    "debug": "^4.4.3",
+    "mqtt": "^5.14.1",
+    "mqtt-packet": "^9.0.2",
+    "net-web": "^0.3.0",
+    "rawr": "^0.19.0"
   },
   "optionalDependencies": {
-    "node-datachannel": "^0.23.0"
+    "node-datachannel": "^0.32.0"
   },
   "devDependencies": {
-    "nodemon": "^3.0.1",
-    "webpack": "^5.88.2",
-    "webpack-cli": "^4.10.0"
+    "@eslint/js": "^9.39.2",
+    "@vitest/coverage-v8": "^4.0.17",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "nodemon": "^3.1.11",
+    "prettier": "^3.8.0",
+    "vitest": "^4.0.17",
+    "webpack": "^5.104.1",
+    "webpack-cli": "^6.0.1"
   }
 }

package/shell.js

@@ -1,7 +1,7 @@
-const net = require('net');
+import net from 'net';
 
-function run(port = 2323) {
-  process.stdin.setRawMode( true );
+export default function run(port = 2323) {
+  process.stdin.setRawMode(true);
   console.log('connecting to localhost:', port, ' ...');
 
   const client = net.createConnection({ port }, () => {
@@ -12,7 +12,7 @@ function run(port = 2323) {
     process.stdin.on('data', (data) => {
       client.write(data);
       // ctrl-c ( end of text )
-      if ( String(data) === '\u0003' ) {
+      if (String(data) === '\u0003') {
         process.exit();
       }
     });
@@ -25,9 +25,5 @@ function run(port = 2323) {
     client.on('error', (err) => {
       console.error(err);
     });
-    
   });
 }
-
-module.exports = run;
-

package/test/mocks/mqtt.mock.js

@@ -0,0 +1,25 @@
+import { vi } from 'vitest';
+import { EventEmitter } from 'events';
+
+export function createMockMqttClient() {
+  const client = new EventEmitter();
+  client.publish = vi.fn();
+  client.subscribe = vi.fn();
+  client.unsubscribe = vi.fn();
+  client.end = vi.fn((force, callback) => {
+    if (typeof force === 'function') {
+      force();
+    } else if (callback) {
+      callback();
+    }
+  });
+  return client;
+}
+
+export function createMockMqtt() {
+  const mockClient = createMockMqttClient();
+  return {
+    connect: vi.fn(() => mockClient),
+    _mockClient: mockClient,
+  };
+}

package/test/mocks/net.mock.js

@@ -0,0 +1,34 @@
+import { vi } from 'vitest';
+import { EventEmitter } from 'events';
+
+export function createMockSocket() {
+  const socket = new EventEmitter();
+  socket.write = vi.fn();
+  socket.end = vi.fn();
+  socket.destroy = vi.fn();
+  socket.connect = vi.fn();
+  socket.setEncoding = vi.fn();
+  socket.setTimeout = vi.fn();
+  return socket;
+}
+
+export function createMockServer() {
+  const server = new EventEmitter();
+  server.listen = vi.fn((port, callback) => {
+    if (callback) callback();
+    return server;
+  });
+  server.close = vi.fn((callback) => {
+    if (callback) callback();
+  });
+  server.address = vi.fn(() => ({ port: 3000 }));
+  return server;
+}
+
+export function createMockNet() {
+  return {
+    createConnection: vi.fn(() => createMockSocket()),
+    createServer: vi.fn(() => createMockServer()),
+    Socket: vi.fn(() => createMockSocket()),
+  };
+}

package/test/mocks/rtc.mock.js

@@ -0,0 +1,9 @@
+import { vi } from 'vitest';
+
+export function createMockRTC() {
+  return {
+    PeerConnection: vi.fn(),
+    offerPeer: vi.fn().mockResolvedValue({ type: 'offer', sdp: 'mock-sdp' }),
+    answerPeer: vi.fn().mockResolvedValue({ type: 'answer', sdp: 'mock-answer-sdp' }),
+  };
+}

package/test/setup.js

@@ -0,0 +1,10 @@
+import { vi } from 'vitest';
+
+// Mock debug to prevent console output during tests
+vi.mock('debug', () => ({
+  default: () => {
+    const debug = () => {};
+    debug.color = 0;
+    return debug;
+  },
+}));

package/test/unit/config.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+describe('config', () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it('should export default config with baseConfig properties', async () => {
+    const { default: config, baseConfig } = await import('../../config.js');
+
+    expect(config).toBeDefined();
+    expect(config.localHost).toBe('localhost');
+    expect(config.port).toBe(3000);
+    expect(config.hsyncBase).toBe('_hs');
+    expect(config.keepalive).toBe(300);
+    expect(config.defaultDynamicHost).toBe('https://demo.hsync.tech');
+    expect(baseConfig).toBeDefined();
+  });
+
+  it('should have connections array with at least one connection', async () => {
+    const { default: config } = await import('../../config.js');
+
+    expect(config.connections).toBeDefined();
+    expect(Array.isArray(config.connections)).toBe(true);
+    expect(config.connections.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should include baseConfig as first connection', async () => {
+    const { default: config, baseConfig } = await import('../../config.js');
+
+    const firstConnection = config.connections[0];
+    expect(firstConnection.localHost).toBe(baseConfig.localHost);
+    expect(firstConnection.port).toBe(baseConfig.port);
+    expect(firstConnection.hsyncBase).toBe(baseConfig.hsyncBase);
+  });
+});

package/test/unit/fetch.test.js

@@ -0,0 +1,189 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+describe('fetch', () => {
+  let apiFetch;
+  let mockFetch;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockFetch = vi.fn();
+    globalThis.fetch = mockFetch;
+    const apiModule = await import('../../lib/fetch.js');
+    apiFetch = apiModule.default;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should be a function', () => {
+    expect(typeof apiFetch).toBe('function');
+  });
+
+  it('should have post, put, and del methods', () => {
+    expect(typeof apiFetch.post).toBe('function');
+    expect(typeof apiFetch.put).toBe('function');
+    expect(typeof apiFetch.del).toBe('function');
+  });
+
+  describe('apiFetch', () => {
+    it('should call fetch with correct headers', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve({ data: 'test' }),
+      });
+
+      await apiFetch('/test');
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        '/test',
+        expect.objectContaining({
+          credentials: 'include',
+          headers: expect.objectContaining({
+            'Content-Type': 'application/json',
+          }),
+        })
+      );
+    });
+
+    it('should parse JSON responses', async () => {
+      const mockData = { key: 'value' };
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve(mockData),
+      });
+
+      const result = await apiFetch('/test');
+
+      expect(result).toEqual(mockData);
+    });
+
+    it('should parse text responses', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'text/plain',
+        },
+        text: () => Promise.resolve('plain text'),
+      });
+
+      const result = await apiFetch('/test');
+
+      expect(result).toBe('plain text');
+    });
+
+    it('should throw error on 4xx/5xx responses', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 404,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve({ error: 'Not found' }),
+      });
+
+      await expect(apiFetch('/test')).rejects.toThrow('Bad response from server');
+    });
+
+    it('should stringify object body', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve({}),
+      });
+
+      await apiFetch('/test', { body: { foo: 'bar' } });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        '/test',
+        expect.objectContaining({
+          body: '{"foo":"bar"}',
+        })
+      );
+    });
+
+    it('should append query string', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve({}),
+      });
+
+      await apiFetch('/test', { query: { foo: 'bar', baz: 'qux' } });
+
+      expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/test?'), expect.any(Object));
+    });
+  });
+
+  describe('apiFetch.post', () => {
+    it('should call apiFetch with POST method', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      await apiFetch.post('/test', { data: 'value' });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        '/test',
+        expect.objectContaining({
+          method: 'POST',
+        })
+      );
+    });
+  });
+
+  describe('apiFetch.put', () => {
+    it('should call apiFetch with PUT method', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      await apiFetch.put('/test', { data: 'value' });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        '/test',
+        expect.objectContaining({
+          method: 'PUT',
+        })
+      );
+    });
+  });
+
+  describe('apiFetch.del', () => {
+    it('should call apiFetch with DELETE method', async () => {
+      mockFetch.mockResolvedValueOnce({
+        status: 200,
+        headers: {
+          get: () => 'application/json',
+        },
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      await apiFetch.del('/test');
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        '/test',
+        expect.objectContaining({
+          method: 'DELETE',
+        })
+      );
+    });
+  });
+});