@yarkivaev/source-to-sink 1.1.1 → 1.2.2

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'
     );
   });

package/test/test_timedBatch.js

@@ -6,7 +6,7 @@ describe('timedBatch', () => {
   it('flushes after interval expires', async () => {
     const received = [];
     const origin = {
-      accept: (record) => received.push(record),
+      accept: (record) => {return received.push(record)},
       flush: () => {},
       stop: () => {}
     };
@@ -15,7 +15,7 @@ describe('timedBatch', () => {
     const interval = 0.05;
     const timed = timedBatch(origin, interval);
     timed.accept({ data: `\u0410\u0411\u0412${Math.random()}` });
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => { setTimeout(resolve, 100); });
     timed.stop();
     assert.strictEqual(flushed, true, 'Should flush after interval');
   });
@@ -23,7 +23,7 @@ describe('timedBatch', () => {
   it('delegates accept to origin', () => {
     const received = [];
     const origin = {
-      accept: (record) => received.push(record),
+      accept: (record) => {return received.push(record)},
       flush: () => {},
       stop: () => {}
     };
@@ -65,14 +65,14 @@ describe('timedBatch', () => {
     let count = 0;
     const origin = {
       accept: () => {},
-      flush: () => { count++; },
+      flush: () => { count += 1; },
       stop: () => {}
     };
     const interval = 0.05;
     const timed = timedBatch(origin, interval);
     timed.accept({ z: Math.random() });
     timed.flush();
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => { setTimeout(resolve, 100); });
     timed.stop();
     assert.strictEqual(count, 1, 'Should not flush twice after manual flush');
   });
@@ -80,8 +80,8 @@ describe('timedBatch', () => {
   it('throws on missing accept method', () => {
     const origin = { flush: () => {}, stop: () => {} };
     assert.throws(
-      () => timedBatch(origin, 1),
-      /Origin must have an accept\(\) method/,
+      () => {return timedBatch(origin, 1)},
+      /Origin must have an accept\(\) method/u,
       'Should reject origin without accept'
     );
   });
@@ -89,8 +89,8 @@ describe('timedBatch', () => {
   it('throws on missing flush method', () => {
     const origin = { accept: () => {}, stop: () => {} };
     assert.throws(
-      () => timedBatch(origin, 1),
-      /Origin must have a flush\(\) method/,
+      () => {return timedBatch(origin, 1)},
+      /Origin must have a flush\(\) method/u,
       'Should reject origin without flush'
     );
   });
@@ -98,8 +98,8 @@ describe('timedBatch', () => {
   it('throws on missing stop method', () => {
     const origin = { accept: () => {}, flush: () => {} };
     assert.throws(
-      () => timedBatch(origin, 1),
-      /Origin must have a stop\(\) method/,
+      () => {return timedBatch(origin, 1)},
+      /Origin must have a stop\(\) method/u,
       'Should reject origin without stop'
     );
   });
@@ -108,8 +108,8 @@ describe('timedBatch', () => {
     const origin = { accept: () => {}, flush: () => {}, stop: () => {} };
     const invalid = -Math.random() * 10;
     assert.throws(
-      () => timedBatch(origin, invalid),
-      /Interval must be a positive number/,
+      () => {return timedBatch(origin, invalid)},
+      /Interval must be a positive number/u,
       'Should reject invalid interval'
     );
   });