BREAKING CHANGE(core): Refactor core IPC: replace node-ipc with native transports and add IpcChannel / IpcServer / IpcClient with heartbeat, reconnection, request/response and pub/sub. Update tests and documentation.

test/test.simple.ts

@@ -0,0 +1,119 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as smartipc from '../ts/index.js';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+
+let server: smartipc.IpcServer;
+let client: smartipc.IpcClient;
+
+// Test TCP transport which is simpler
+tap.test('should create and start a TCP IPC server', async () => {
+  server = smartipc.SmartIpc.createServer({
+    id: 'tcp-test-server',
+    host: 'localhost',
+    port: 18765,
+    heartbeat: false // Disable heartbeat for simpler testing
+  });
+
+  await server.start();
+  expect(server.getStats().isRunning).toBeTrue();
+});
+
+tap.test('should create and connect a TCP client', async () => {
+  client = smartipc.SmartIpc.createClient({
+    id: 'tcp-test-server',
+    host: 'localhost', 
+    port: 18765,
+    clientId: 'test-client-1',
+    metadata: { name: 'Test Client' },
+    heartbeat: false
+  });
+
+  await client.connect();
+  expect(client.getIsConnected()).toBeTrue();
+  expect(client.getClientId()).toEqual('test-client-1');
+});
+
+tap.test('should send messages between server and client', async () => {
+  const messageReceived = smartpromise.defer();
+
+  // Server listens for messages
+  server.onMessage('test-message', (payload, clientId) => {
+    expect(payload).toEqual({ data: 'Hello Server' });
+    expect(clientId).toEqual('test-client-1');
+    messageReceived.resolve();
+  });
+
+  // Client sends message
+  await client.sendMessage('test-message', { data: 'Hello Server' });
+  
+  await messageReceived.promise;
+});
+
+tap.test('should handle request/response pattern', async () => {
+  // Server handles requests
+  server.onMessage('add', async (payload: {a: number, b: number}, clientId) => {
+    return { result: payload.a + payload.b };
+  });
+
+  // Client makes request
+  const response = await client.request<{a: number, b: number}, {result: number}>(
+    'add',
+    { a: 5, b: 3 },
+    { timeout: 5000 }
+  );
+
+  expect(response.result).toEqual(8);
+});
+
+tap.test('should handle pub/sub pattern', async () => {
+  // Create a second client
+  const client2 = smartipc.SmartIpc.createClient({
+    id: 'tcp-test-server',
+    host: 'localhost',
+    port: 18765,
+    clientId: 'test-client-2',
+    metadata: { name: 'Test Client 2' },
+    heartbeat: false
+  });
+  
+  await client2.connect();
+  
+  const messageReceived = smartpromise.defer();
+  
+  // Client 1 subscribes to a topic
+  await client.subscribe('news', (payload) => {
+    expect(payload).toEqual({ headline: 'Breaking news!' });
+    messageReceived.resolve();
+  });
+  
+  // Give server time to process subscription
+  await smartdelay.delayFor(100);
+  
+  // Client 2 publishes to the topic
+  await client2.publish('news', { headline: 'Breaking news!' });
+  
+  await messageReceived.promise;
+  
+  await client2.disconnect();
+});
+
+tap.test('should track metrics correctly', async () => {
+  const stats = client.getStats();
+  
+  expect(stats.connected).toBeTrue();
+  expect(stats.metrics.messagesSent).toBeGreaterThan(0);
+  expect(stats.metrics.messagesReceived).toBeGreaterThan(0);
+  expect(stats.metrics.bytesSent).toBeGreaterThan(0);
+  expect(stats.metrics.bytesReceived).toBeGreaterThan(0);
+});
+
+tap.test('should cleanup and close connections', async () => {
+  await client.disconnect();
+  await server.stop();
+  
+  expect(server.getStats().isRunning).toBeFalse();
+  expect(client.getIsConnected()).toBeFalse();
+});
+
+export default tap.start();