@yarkivaev/source-to-sink 1.1.0 → 1.2.2

package/test/test_modbusSource.js

@@ -8,8 +8,8 @@ describe('modbusSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     assert.throws(
-      () => modbusSource('', 502, 4000, 14, 5, collector, clk),
-      /Host must be a non-empty string/,
+      () => {return modbusSource('', 502, 4000, 14, 5, collector, clk)},
+      /Host must be a non-empty string/u,
       'Should reject empty host'
     );
   });
@@ -18,8 +18,8 @@ describe('modbusSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     assert.throws(
-      () => modbusSource(null, 502, 4000, 14, 5, collector, clk),
-      /Host must be a non-empty string/,
+      () => {return modbusSource(null, 502, 4000, 14, 5, collector, clk)},
+      /Host must be a non-empty string/u,
       'Should reject null host'
     );
   });
@@ -28,8 +28,8 @@ describe('modbusSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     assert.throws(
-      () => modbusSource('192.168.2.148', -1, 4000, 14, 5, collector, clk),
-      /Port must be a positive number/,
+      () => {return modbusSource('192.168.2.148', -1, 4000, 14, 5, collector, clk)},
+      /Port must be a positive number/u,
       'Should reject negative port'
     );
   });
@@ -38,8 +38,8 @@ describe('modbusSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     assert.throws(
-      () => modbusSource('192.168.2.148', 502, -1, 14, 5, collector, clk),
-      /Address must be a non-negative number/,
+      () => {return modbusSource('192.168.2.148', 502, -1, 14, 5, collector, clk)},
+      /Address must be a non-negative number/u,
       'Should reject negative address'
     );
   });
@@ -48,8 +48,8 @@ describe('modbusSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     assert.throws(
-      () => modbusSource('192.168.2.148', 502, 4000, 0, 5, collector, clk),
-      /Count must be a positive number/,
+      () => {return modbusSource('192.168.2.148', 502, 4000, 0, 5, collector, clk)},
+      /Count must be a positive number/u,
       'Should reject zero count'
     );
   });
@@ -57,8 +57,8 @@ describe('modbusSource', () => {
   it('throws on missing collector', () => {
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     assert.throws(
-      () => modbusSource('192.168.2.148', 502, 4000, 14, 5, null, clk),
-      /Collector must have an accept\(\) method/,
+      () => {return modbusSource('192.168.2.148', 502, 4000, 14, 5, null, clk)},
+      /Collector must have an accept\(\) method/u,
       'Should reject null collector'
     );
   });
@@ -66,8 +66,8 @@ describe('modbusSource', () => {
   it('throws on missing clock', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => modbusSource('192.168.2.148', 502, 4000, 14, 5, collector, null),
-      /Clock must have a millis\(\) method/,
+      () => {return modbusSource('192.168.2.148', 502, 4000, 14, 5, collector, null)},
+      /Clock must have a millis\(\) method/u,
       'Should reject null clock'
     );
   });
@@ -93,4 +93,27 @@ describe('modbusSource', () => {
     source.stop();
     assert.strictEqual(true, true, 'Should not throw when stopping without start');
   });
+
+  it('retries connection on failure', async () => {
+    let logged = false;
+    const log = { error: () => { logged = true; } };
+    const collector = { accept: () => {} };
+    const clk = fakeClock(Math.floor(Math.random() * 10000));
+    const source = modbusSource(`\u00df${Math.random()}`, 502, 4000, 14, 5, collector, clk, log);
+    source.start();
+    await new Promise(resolve => { setTimeout(resolve, 200); });
+    source.stop();
+    assert.strictEqual(logged, true, 'Should log connection failure and retry');
+  });
+
+  it('does not crash process on connection failure', async () => {
+    const log = { error: () => {} };
+    const collector = { accept: () => {} };
+    const clk = fakeClock(Math.floor(Math.random() * 10000));
+    const source = modbusSource(`\u0420${Math.random()}`, 502, 4000, 14, 5, collector, clk, log);
+    source.start();
+    await new Promise(resolve => { setTimeout(resolve, 200); });
+    source.stop();
+    assert.strictEqual(true, true, 'Should not crash on unreachable host');
+  });
 });

package/test/test_mqttSink.js

@@ -5,16 +5,16 @@ import mqttSink from '../src/mqttSink.js';
 describe('mqttSink', () => {
   it('throws on empty url', () => {
     assert.throws(
-      () => mqttSink(''),
-      /URL must be a non-empty string/,
+      () => {return mqttSink('')},
+      /URL must be a non-empty string/u,
       'Should reject empty URL'
     );
   });
 
   it('throws on missing url', () => {
     assert.throws(
-      () => mqttSink(null),
-      /URL must be a non-empty string/,
+      () => {return mqttSink(null)},
+      /URL must be a non-empty string/u,
       'Should reject null URL'
     );
   });
@@ -37,8 +37,8 @@ describe('mqttSink', () => {
   it('throws on write when not connected', () => {
     const sink = mqttSink(`mqtt://\u00df${Math.random()}`);
     assert.throws(
-      () => sink.write([{ topic: `\u00e9${Math.random()}`, payload: `${Math.random()}` }]),
-      /Sink is not connected/,
+      () => {return sink.write([{ topic: `\u00e9${Math.random()}`, payload: `${Math.random()}` }])},
+      /Sink is not connected/u,
       'Should reject write when not connected'
     );
   });

package/test/test_mqttSource.js

@@ -6,8 +6,8 @@ describe('mqttSource', () => {
   it('throws on missing url', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => mqttSource(null, 'test/topic', collector),
-      /URL must be a non-empty string/,
+      () => {return mqttSource(null, 'test/topic', collector)},
+      /URL must be a non-empty string/u,
       'Should reject missing url'
     );
   });
@@ -15,8 +15,8 @@ describe('mqttSource', () => {
   it('throws on empty url', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => mqttSource('', 'test/topic', collector),
-      /URL must be a non-empty string/,
+      () => {return mqttSource('', 'test/topic', collector)},
+      /URL must be a non-empty string/u,
       'Should reject empty url'
     );
   });
@@ -24,16 +24,16 @@ describe('mqttSource', () => {
   it('throws on empty topic', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => mqttSource('mqtt://localhost:1883', '', collector),
-      /Topic must be a non-empty string/,
+      () => {return mqttSource('mqtt://localhost:1883', '', collector)},
+      /Topic must be a non-empty string/u,
       'Should reject empty topic'
     );
   });
 
   it('throws on missing collector', () => {
     assert.throws(
-      () => mqttSource('mqtt://localhost:1883', 'test', null),
-      /Collector must have an accept\(\) method/,
+      () => {return mqttSource('mqtt://localhost:1883', 'test', null)},
+      /Collector must have an accept\(\) method/u,
       'Should reject missing collector'
     );
   });

package/test/test_pollingSource.js

@@ -6,7 +6,7 @@ import fakeClock from './fakeClock.js';
 describe('pollingSource', () => {
   it('polls fetch after interval', async () => {
     let polled = false;
-    const fetch = async () => {
+    const fetch = () => {
       polled = true;
       return [];
     };
@@ -14,7 +14,7 @@ describe('pollingSource', () => {
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const source = pollingSource(fetch, 0.05, collector, clk);
     source.start();
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => { setTimeout(resolve, 100); });
     source.stop();
     assert.strictEqual(polled, true, 'Should poll fetch after interval');
   });
@@ -25,19 +25,19 @@ describe('pollingSource', () => {
       { ts: Math.random(), line: `\u00e9${Math.random()}` },
       { ts: Math.random(), line: `\u4e2d${Math.random()}` }
     ];
-    const fetch = async () => entries;
-    const collector = { accept: (entry) => received.push(entry) };
+    const fetch = () => {return entries};
+    const collector = { accept: (entry) => {return received.push(entry)} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const source = pollingSource(fetch, 0.05, collector, clk);
     source.start();
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => { setTimeout(resolve, 100); });
     source.stop();
     assert.strictEqual(received.length, entries.length, 'Should forward all entries to collector');
   });
 
   it('passes time window to fetch', async () => {
     let captured = null;
-    const fetch = async (since, until) => {
+    const fetch = (since, until) => {
       captured = { since, until };
       return [];
     };
@@ -45,14 +45,14 @@ describe('pollingSource', () => {
     const clk = fakeClock(1000);
     const source = pollingSource(fetch, 0.05, collector, clk);
     source.start();
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => { setTimeout(resolve, 100); });
     source.stop();
     assert.strictEqual(captured !== null, true, 'Should pass time window to fetch');
   });
 
   it('ignores duplicate start calls', () => {
     let count = 0;
-    const fetch = async () => {
+    const fetch = () => {
       count += 1;
       return [];
     };
@@ -66,7 +66,7 @@ describe('pollingSource', () => {
   });
 
   it('ignores stop when not started', () => {
-    const fetch = async () => [];
+    const fetch = () => {return []};
     const collector = { accept: () => {} };
     const clk = fakeClock(0);
     const source = pollingSource(fetch, 60, collector, clk);
@@ -76,7 +76,7 @@ describe('pollingSource', () => {
 
   it('stops polling on stop', async () => {
     let count = 0;
-    const fetch = async () => {
+    const fetch = () => {
       count += 1;
       return [];
     };
@@ -84,10 +84,10 @@ describe('pollingSource', () => {
     const clk = fakeClock(0);
     const source = pollingSource(fetch, 0.03, collector, clk);
     source.start();
-    await new Promise(resolve => setTimeout(resolve, 50));
+    await new Promise(resolve => { setTimeout(resolve, 50); });
     source.stop();
     const before = count;
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => { setTimeout(resolve, 100); });
     assert.strictEqual(count, before, 'Should stop polling after stop');
   });
 
@@ -95,39 +95,39 @@ describe('pollingSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(0);
     assert.throws(
-      () => pollingSource(null, 10, collector, clk),
-      /Fetch must be a function/,
+      () => {return pollingSource(null, 10, collector, clk)},
+      /Fetch must be a function/u,
       'Should reject missing fetch'
     );
   });
 
   it('throws on invalid interval', () => {
-    const fetch = async () => [];
+    const fetch = () => {return []};
     const collector = { accept: () => {} };
     const clk = fakeClock(0);
     assert.throws(
-      () => pollingSource(fetch, -1, collector, clk),
-      /Interval must be a positive number/,
+      () => {return pollingSource(fetch, -1, collector, clk)},
+      /Interval must be a positive number/u,
       'Should reject invalid interval'
     );
   });
 
   it('throws on missing collector', () => {
-    const fetch = async () => [];
+    const fetch = () => {return []};
     const clk = fakeClock(0);
     assert.throws(
-      () => pollingSource(fetch, 10, null, clk),
-      /Collector must have an accept\(\) method/,
+      () => {return pollingSource(fetch, 10, null, clk)},
+      /Collector must have an accept\(\) method/u,
       'Should reject missing collector'
     );
   });
 
   it('throws on missing clock', () => {
-    const fetch = async () => [];
+    const fetch = () => {return []};
     const collector = { accept: () => {} };
     assert.throws(
-      () => pollingSource(fetch, 10, collector, null),
-      /Clock must have a millis\(\) method/,
+      () => {return pollingSource(fetch, 10, collector, null)},
+      /Clock must have a millis\(\) method/u,
       'Should reject missing clock'
     );
   });

package/test/test_postgresSink.js

@@ -5,48 +5,48 @@ import postgresSink, { deduplicate } from '../src/postgresSink.js';
 describe('postgresSink', () => {
   it('throws on missing url', () => {
     assert.throws(
-      () => postgresSink(null, 'metrics', ['ts', 'value']),
-      /URL must be a non-empty string/,
+      () => {return postgresSink(null, 'metrics', ['ts', 'value'])},
+      /URL must be a non-empty string/u,
       'Should reject missing url'
     );
   });
 
   it('throws on empty url', () => {
     assert.throws(
-      () => postgresSink('', 'metrics', ['ts', 'value']),
-      /URL must be a non-empty string/,
+      () => {return postgresSink('', 'metrics', ['ts', 'value'])},
+      /URL must be a non-empty string/u,
       'Should reject empty url'
     );
   });
 
   it('throws on missing table', () => {
     assert.throws(
-      () => postgresSink('postgresql://localhost:5432/db', null, ['ts', 'value']),
-      /Table must be a non-empty string/,
+      () => {return postgresSink('postgresql://localhost:5432/db', null, ['ts', 'value'])},
+      /Table must be a non-empty string/u,
       'Should reject missing table'
     );
   });
 
   it('throws on empty table', () => {
     assert.throws(
-      () => postgresSink('postgresql://localhost:5432/db', '', ['ts', 'value']),
-      /Table must be a non-empty string/,
+      () => {return postgresSink('postgresql://localhost:5432/db', '', ['ts', 'value'])},
+      /Table must be a non-empty string/u,
       'Should reject empty table'
     );
   });
 
   it('throws on missing columns', () => {
     assert.throws(
-      () => postgresSink('postgresql://localhost:5432/db', 'metrics', null),
-      /Columns must be a non-empty array/,
+      () => {return postgresSink('postgresql://localhost:5432/db', 'metrics', null)},
+      /Columns must be a non-empty array/u,
       'Should reject missing columns'
     );
   });
 
   it('throws on empty columns', () => {
     assert.throws(
-      () => postgresSink('postgresql://localhost:5432/db', 'metrics', []),
-      /Columns must be a non-empty array/,
+      () => {return postgresSink('postgresql://localhost:5432/db', 'metrics', [])},
+      /Columns must be a non-empty array/u,
       'Should reject empty columns'
     );
   });

package/test/test_sqliteSink.js

@@ -0,0 +1,176 @@
+import assert from 'node:assert';
+import { describe, it } from 'mocha';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import Database from 'better-sqlite3';
+import sqliteSink from '../src/sqliteSink.js';
+
+describe('sqliteSink', () => {
+  it('throws on missing path', () => {
+    assert.throws(
+      () => {return sqliteSink(null, 'metrics', ['ts', 'value'])},
+      /Path must be a non-empty string/u,
+      'Should reject missing path'
+    );
+  });
+
+  it('throws on empty path', () => {
+    assert.throws(
+      () => {return sqliteSink('', 'metrics', ['ts', 'value'])},
+      /Path must be a non-empty string/u,
+      'Should reject empty path'
+    );
+  });
+
+  it('throws on missing table', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    try {
+      assert.throws(
+        () => {return sqliteSink(join(dir, 'db.sqlite'), null, ['ts', 'value'])},
+        /Table must be a non-empty string/u,
+        'Should reject missing table'
+      );
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('throws on empty table', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    try {
+      assert.throws(
+        () => {return sqliteSink(join(dir, 'db.sqlite'), '', ['ts', 'value'])},
+        /Table must be a non-empty string/u,
+        'Should reject empty table'
+      );
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('throws on missing columns', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    try {
+      assert.throws(
+        () => {return sqliteSink(join(dir, 'db.sqlite'), 'metrics', null)},
+        /Columns must be a non-empty array/u,
+        'Should reject missing columns'
+      );
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('throws on empty columns', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    try {
+      assert.throws(
+        () => {return sqliteSink(join(dir, 'db.sqlite'), 'metrics', [])},
+        /Columns must be a non-empty array/u,
+        'Should reject empty columns'
+      );
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('returns sink with write method', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    const path = join(dir, 'db.sqlite');
+    const db = new Database(path);
+    db.exec('CREATE TABLE metrics (topic TEXT, ts REAL, value REAL)');
+    db.close();
+    try {
+      const sink = sqliteSink(path, 'metrics', ['topic', 'ts', 'value']);
+      assert.strictEqual(typeof sink.write, 'function', 'Should have write method');
+      sink.close();
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('inserts records into the database', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    const path = join(dir, `db-${Math.random()}.sqlite`);
+    const db = new Database(path);
+    db.exec('CREATE TABLE metrics (topic TEXT, ts REAL, value REAL)');
+    db.close();
+    const topic = `sénsör/${Math.random()}`;
+    const ts = Date.now();
+    const value = Math.random() * 1000;
+    try {
+      const sink = sqliteSink(path, 'metrics', ['topic', 'ts', 'value']);
+      sink.write([{ topic, ts, value }]);
+      sink.close();
+      const reader = new Database(path);
+      const rows = reader.prepare('SELECT topic, ts, value FROM metrics').all();
+      reader.close();
+      assert.strictEqual(rows.length, 1, 'Should insert exactly one record');
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('inserts batch of records atomically', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    const path = join(dir, `db-${Math.random()}.sqlite`);
+    const db = new Database(path);
+    db.exec('CREATE TABLE metrics (topic TEXT, ts REAL, value REAL)');
+    db.close();
+    const count = 5 + Math.floor(Math.random() * 10);
+    const records = Array.from({ length: count }, (_, i) => {return {
+      topic: `tøpic/${Math.random()}`,
+      ts: Date.now() + i,
+      value: Math.random()
+    }});
+    try {
+      const sink = sqliteSink(path, 'metrics', ['topic', 'ts', 'value']);
+      sink.write(records);
+      sink.close();
+      const reader = new Database(path);
+      const rows = reader.prepare('SELECT COUNT(*) as cnt FROM metrics').get();
+      reader.close();
+      assert.strictEqual(rows.cnt, count, 'Should insert all records in batch');
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('preserves record values', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    const path = join(dir, `db-${Math.random()}.sqlite`);
+    const db = new Database(path);
+    db.exec('CREATE TABLE metrics (topic TEXT, ts REAL, value REAL)');
+    db.close();
+    const topic = `données/capteur-${Math.random()}`;
+    const ts = Date.now() + Math.floor(Math.random() * 100000);
+    const value = Math.random() * 500;
+    try {
+      const sink = sqliteSink(path, 'metrics', ['topic', 'ts', 'value']);
+      sink.write([{ topic, ts, value }]);
+      sink.close();
+      const reader = new Database(path);
+      const row = reader.prepare('SELECT topic, ts, value FROM metrics').get();
+      reader.close();
+      assert.strictEqual(row.topic, topic, 'Should preserve topic value');
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it('returns sink with close method', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sink-'));
+    const path = join(dir, 'db.sqlite');
+    const db = new Database(path);
+    db.exec('CREATE TABLE metrics (topic TEXT, ts REAL, value REAL)');
+    db.close();
+    try {
+      const sink = sqliteSink(path, 'metrics', ['topic', 'ts', 'value']);
+      assert.strictEqual(typeof sink.close, 'function', 'Should have close method');
+      sink.close();
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+});

package/test/test_stompSource.js

@@ -6,8 +6,8 @@ describe('stompSource', () => {
   it('throws on missing url', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => stompSource(null, '/queue/test', collector),
-      /URL must be a non-empty string/,
+      () => {return stompSource(null, '/queue/test', collector)},
+      /URL must be a non-empty string/u,
       'Should reject missing url'
     );
   });
@@ -15,8 +15,8 @@ describe('stompSource', () => {
   it('throws on empty url', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => stompSource('', '/queue/test', collector),
-      /URL must be a non-empty string/,
+      () => {return stompSource('', '/queue/test', collector)},
+      /URL must be a non-empty string/u,
       'Should reject empty url'
     );
   });
@@ -24,16 +24,16 @@ describe('stompSource', () => {
   it('throws on empty destination', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => stompSource('stomp://localhost:61613', '', collector),
-      /Destination must be a non-empty string/,
+      () => {return stompSource('stomp://localhost:61613', '', collector)},
+      /Destination must be a non-empty string/u,
       'Should reject empty destination'
     );
   });
 
   it('throws on missing collector', () => {
     assert.throws(
-      () => stompSource('stomp://localhost:61613', '/queue/test', null),
-      /Collector must have an accept\(\) method/,
+      () => {return stompSource('stomp://localhost:61613', '/queue/test', null)},
+      /Collector must have an accept\(\) method/u,
       'Should reject missing collector'
     );
   });