@superhero/eventflow-db 4.0.0

package/index.test.js

@@ -0,0 +1,266 @@
+import Config     from '@superhero/config'
+import Locator    from '@superhero/locator'
+import { locate } from '@superhero/eventflow-db'
+import assert     from 'node:assert/strict'
+import { after, suite, test }  from 'node:test'
+
+suite('@superhero/eventflow-db', async () =>
+{
+  const 
+    config  = new Config(),
+    locator = new Locator()
+
+  locator.set('@superhero/config', config)
+  await config.add('./config.js')
+
+  const db = locate(locator)
+
+  test('Setup table schemas', async (sub) =>
+  {
+    await assert.doesNotReject(db.setupTableSchemas())
+
+    await sub.test('Persist a hub', async (sub) =>
+    {
+      const hub = 
+      { 
+        id            : 'test_hub_id_' + Date.now().toString(36), 
+        external_ip   : '127.0.0.1',
+        external_port : 50001,
+        internal_ip   : '127.0.0.1',
+        internal_port : 50001,
+      }
+
+      await assert.doesNotReject(db.persistHub(hub))
+
+      await sub.test('Read online hubs', async () =>
+      {
+        const hubs = await db.readOnlineHubs()
+        assert.ok(hubs.length > 0, 'Online hubs should be returned')
+        assert.equal(hubs[0].id, hub.id)
+        assert.equal(hubs[0].external_ip, hub.external_ip)
+        assert.equal(hubs[0].internal_ip, hub.internal_ip)
+        assert.equal(hubs[0].external_port, hub.external_port)
+        assert.equal(hubs[0].internal_port, hub.internal_port)
+      })
+
+      await sub.test('Persisting an event should generate an ID if not provided', async (sub) => 
+      {
+        const
+          domain  = 'foo',
+          pid     = 'bar',
+          name    = 'baz',
+          event   = { domain, pid, name, data: { qux: 'foobar' } },
+          id      = await db.persistEvent(event)
+  
+        assert.ok(id)
+        event.id = id
+    
+        await sub.test('Read an event by id should return the same data as when persisted the event', async () => 
+        {
+          const readEvent = await db.readEvent(event.id)
+  
+          assert.equal(readEvent.id,        event.id)
+          assert.equal(readEvent.domain,    event.domain)
+          assert.equal(readEvent.pid,       event.pid)
+          assert.equal(readEvent.name,      event.name)
+          assert.deepEqual(readEvent.data,  event.data)
+        })
+
+        await sub.test('Schedule a persisted event', async (sub) =>
+        {
+          const scheduledEvent = { event_id:event.id, scheduled: new Date() }
+
+          const success = await db.persistEventScheduled(scheduledEvent)
+          assert.ok(success, 'Event should be scheduled')
+
+          await sub.test('Read all scheduled events', async () =>
+          {
+            const events = await db.readEventsScheduled()
+            assert.ok(events.length > 0, 'Scheduled events should be returned')
+          })
+
+          await sub.test('Update scheduled event as executed', async () => 
+          {
+            const updated = await db.updateEventScheduledExecuted(scheduledEvent.event_id)
+            assert.ok(updated, 'Scheduled event should be marked as executed')
+          })
+
+          await sub.test('Update scheduled event as success', async () => 
+          {
+            const updated = await db.updateEventScheduledSuccess(scheduledEvent.event_id)
+            assert.ok(updated, 'Scheduled event should be marked as success')
+          })
+
+          await sub.test('Update scheduled event as failed', async () => 
+          {
+            const updated = await db.updateEventScheduledFailed(scheduledEvent.event_id)
+            assert.ok(updated, 'Scheduled event should be marked as failed')
+          })
+        })
+
+        await sub.test('Publish a persisted event', async (sub) => 
+        {
+          const publishedEvent = { event_id:event.id, publisher:'spoke_id' }
+          const success = await db.persistEventPublished(publishedEvent)
+          assert.ok(success, 'Event should be published')
+
+          await sub.test('Update published event to consumed by hub', async () => 
+          {
+            const success = await db.updateEventPublishedToConsumedByHub(event.id, hub.id)
+            assert.ok(success, 'Event should be updated to consumed by hub')
+          })
+  
+          await sub.test('Update published event to consumed by spoke', async () => 
+          {
+            const success = await db.updateEventPublishedToConsumedBySpoke(event.id, publishedEvent.publisher)
+            assert.ok(success, 'Event should be updated to consumed by spoke')
+          })
+
+          await sub.test('Update published event to success', async () => 
+          {
+            const success = await db.updateEventPublishedToSuccess(event.id)
+            assert.ok(success, 'Event should be updated to success')
+          })
+
+          await sub.test('Update published event to failed', async () => 
+          {
+            const success = await db.updateEventPublishedToFailed(event.id)
+            assert.ok(success, 'Event should be updated to failed')
+          })
+
+          await sub.test('Update published event to orphan', async () => 
+          {
+            const success = await db.updateEventPublishedToOrphan(id)
+            assert.ok(success, 'Event should be updated to orphan')
+          })
+        })
+
+        await sub.test('Persist event cpid association', async (sub) =>
+        {
+          const cpid = 'test_cpid'
+          const success = await db.persistEventCpid(event.id, cpid)
+          assert.ok(success, 'Event cpid association should be persisted')
+
+          await sub.test('Read events by domain and cpid', async () =>
+          {
+            const events = await db.readEventsByDomainAndCpid(event.domain, cpid)
+            assert.ok(events.length, 'Events found by domain and cpid')
+          })
+
+          await sub.test('Read associated cpid by event id', async () =>
+          {
+            const readCpid = await db.readEventCpidByEventId(event.id)
+            assert.ok(readCpid.length > 0, 'Event cpid association should be found')
+            assert.equal(readCpid[0], cpid)
+          })
+
+          await sub.test('Delete associated cpid by event id', async () =>
+          {
+            const success = await db.deleteEventCpid(event.id, cpid)
+            assert.ok(success, 'Event cpid association should be deleted')
+          })
+
+          await sub.test('Read deleted associated cpid by event id returns empty', async () =>
+          {
+            const readCpid = await db.readEventCpidByEventId(event.id)
+            assert.ok(readCpid.length === 0, 'Event cpid association should be empty')
+          })
+        })
+
+        await sub.test('Persist event eid association', async (sub) =>
+        {
+          const eid = 'test_eid'
+          const success = await db.persistEventEid(event.id, eid)
+          assert.ok(success, 'Event eid association should be persisted')
+
+          await sub.test('Read events by eid', async () =>
+          {
+            const events = await db.readEventsByEid(eid)
+            assert.ok(events.length, 'Events found by eid')
+          })
+
+          await sub.test('Read events by domain and eid', async () =>
+          {
+            const events = await db.readEventsByDomainAndEid(event.domain, eid)
+            assert.ok(events.length, 'Events found by domain and eid')
+          })
+
+          await sub.test('Read associated eid by event id', async () =>
+          {
+            const readEid = await db.readEventEidByEventId(event.id)
+            assert.ok(readEid.length > 0, 'Event eid association should be found')
+            assert.equal(readEid[0], eid)
+          })
+
+          await sub.test('Delete associated eid by event id', async () =>
+          {
+            const success = await db.deleteEventEid(event.id, eid)
+            assert.ok(success, 'Event eid association should be deleted')
+          })
+
+          await sub.test('Read deleted associated eid by event id returns empty', async () =>
+          {
+            const readEid = await db.readEventEidByEventId(event.id)
+            assert.ok(readEid.length === 0, 'Event eid association should be empty')
+          })
+        })
+
+        await sub.test('Delete event', async (sub) =>
+        {
+          const success = await db.deleteEvent(event.id)
+          assert.ok(success, 'Event should be deleted')
+
+          await sub.test('Reading a deleted event rejects', async () =>
+          {
+            await assert.rejects(db.readEvent(event.id))
+          })
+        })
+
+        await sub.test('By domain and pid', async (sub) =>
+        {
+          const event_id = await db.persistEvent(event)
+          assert.ok(event_id, 'Event should be persisted')
+
+          await sub.test('Read event by domain and pid', async () =>
+          {
+            const eventlog = await db.readEventsByDomainAndPid(domain, pid)
+            assert.ok(eventlog.length > 0, 'Event should be found')
+          })
+
+          await sub.test('Delete event by domain and pid', async () =>
+          {
+            const success = await db.deleteEventByDomainAndPid(event.domain, event.pid)
+            assert.ok(success, 'Should be possible to delete event by domain and pid')
+          })
+
+          await sub.test('Read empty eventlog by domain and pid', async () =>
+          {
+            const eventlog = await db.readEventsByDomainAndPid(domain, pid)
+            assert.ok(eventlog.length === 0, 'Eventlog should be empty')
+          })
+        })
+      })
+
+      await sub.test('Persist log', async () =>
+      {
+        const log = { agent:hub.id, message: 'Test log', error: { message: 'Test error' } }
+        await assert.doesNotReject(db.persistLog(log))
+      })
+
+      await sub.test('Update hub to quit', async () => 
+      {
+        const updated = await db.updateHubToQuit(hub.id)
+        assert.ok(updated, 'Hub should be updated to quit')
+      })
+    })
+  
+    await sub.test('Reading a non existing event should reject with an error', async () => 
+    {
+      await assert.rejects(
+        db.readEvent('nonExistingId'),
+        { code : 'E_EVENTFLOW_DB_EVENT_NOT_FOUND' })
+    })
+  })
+
+  after(() => db.destroy())
+})

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@superhero/eventflow-db",
+  "version": "4.0.0",
+  "description": "Eventflow db is a set of common database logic in the eventflow ecosystem.",
+  "keywords": [
+    "eventflow"
+  ],
+  "main": "src/config.js",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./index.js"
+  },
+  "dependencies": {
+    "mysql2": "^3.11.5",
+    "@superhero/db": "^0.5.0"
+  },
+  "devDependencies": {
+    "@superhero/config": "4.1.2",
+    "@superhero/locator": "4.2.0"
+  },
+  "scripts": {
+    "build": "docker run --rm --name eventflow-mysql -e MYSQL_ROOT_PASSWORD=root -e MYSQL_DATABASE=eventflow -p 3306:3306 -d mysql:latest",
+    "test": "node --trace-warnings --test --experimental-test-coverage"
+  },
+  "author": {
+    "name": "Erik Landvall",
+    "email": "erik@landvall.se"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/superhero/eventflow-db.git"
+  }
+}

package/sql/event/delete-by-id.sql

@@ -0,0 +1,3 @@
+DELETE 
+FROM event
+WHERE id = ?

package/sql/event/delete-by-pid-domain.sql

@@ -0,0 +1,4 @@
+DELETE 
+FROM event
+WHERE pid     = ?
+  AND domain  = ?

package/sql/event/persist.sql

@@ -0,0 +1,3 @@
+INSERT
+INTO event
+SET ?

package/sql/event/read-by-id.sql

@@ -0,0 +1,3 @@
+SELECT *
+FROM event
+WHERE id = ?

package/sql/event/read-by-pid-domain.sql

@@ -0,0 +1,4 @@
+SELECT *
+FROM event
+WHERE pid    = ?
+  AND domain = ?

package/sql/event/schema.sql

@@ -0,0 +1,19 @@
+CREATE TABLE IF NOT EXISTS event
+(
+  id        VARCHAR(64) NOT NULL,
+  timestamp DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+  domain    VARCHAR(64) NOT NULL,
+  rid       VARCHAR(64)     NULL,
+  pid       VARCHAR(64) NOT NULL,
+  name      VARCHAR(64) NOT NULL,
+  data      JSON        NOT NULL,
+
+  PRIMARY KEY (id),
+  FOREIGN KEY (rid) REFERENCES event (id) ON DELETE SET NULL,
+
+  INDEX idx_rid         (rid),
+  INDEX idx_name        (name, timestamp),
+  INDEX idx_domain      (domain, timestamp),
+  INDEX idx_domain_pid  (domain, pid, timestamp)
+)
+ENGINE=InnoDB

package/sql/event_cpid/delete.sql

@@ -0,0 +1,4 @@
+DELETE 
+FROM event_cpid
+WHERE event_id = ?
+  AND cpid = ?

package/sql/event_cpid/persist.sql

@@ -0,0 +1,3 @@
+INSERT
+INTO event_cpid
+SET event_id = ?, cpid = ?

package/sql/event_cpid/read-by-cpid-domain.sql

@@ -0,0 +1,6 @@
+SELECT event.*
+FROM event_cpid
+JOIN event 
+  ON event_id = id
+WHERE cpid = ?
+  AND domain = ?

package/sql/event_cpid/read-by-event_id.sql

@@ -0,0 +1,3 @@
+SELECT cpid
+FROM event_cpid
+WHERE event_id = ?

package/sql/event_cpid/schema.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS event_cpid 
+(
+  event_id  VARCHAR(64) NOT NULL,
+  cpid      VARCHAR(64) NOT NULL,
+
+  PRIMARY KEY (event_id, cpid),
+  FOREIGN KEY (event_id) REFERENCES event (id)
+    ON UPDATE CASCADE
+    ON DELETE CASCADE,
+  INDEX idx_cpid (cpid)
+)
+ENGINE=InnoDB

package/sql/event_eid/delete.sql

@@ -0,0 +1,4 @@
+DELETE 
+FROM event_eid
+WHERE event_id = ?
+  AND eid = ?

package/sql/event_eid/persist.sql

@@ -0,0 +1,3 @@
+INSERT
+INTO event_eid
+SET event_id = ?, eid = ?

package/sql/event_eid/read-by-eid-domain.sql

@@ -0,0 +1,6 @@
+SELECT event.*
+FROM event_eid
+JOIN event 
+  ON event_id = id
+WHERE eid = ?
+  AND domain = ?

package/sql/event_eid/read-by-eid.sql

@@ -0,0 +1,5 @@
+SELECT event.*
+FROM event_eid
+JOIN event 
+  ON event_id = id
+WHERE eid = ?

package/sql/event_eid/read-by-event_id.sql

@@ -0,0 +1,3 @@
+SELECT eid
+FROM event_eid
+WHERE event_id = ?

package/sql/event_eid/schema.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS event_eid 
+(
+  event_id  VARCHAR(64) NOT NULL,
+  eid       VARCHAR(64) NOT NULL,
+
+  PRIMARY KEY (event_id, eid),
+  FOREIGN KEY (event_id) REFERENCES event (id)
+    ON UPDATE CASCADE
+    ON DELETE CASCADE,
+  INDEX idx_eid (eid)
+)
+ENGINE=InnoDB

package/sql/event_published/persist.sql

@@ -0,0 +1,3 @@
+INSERT
+INTO event_published
+SET ?

package/sql/event_published/schema.sql

@@ -0,0 +1,23 @@
+CREATE TABLE IF NOT EXISTS event_published 
+(
+  event_id        VARCHAR(64) NOT NULL,
+  published       DATETIME    NOT NULL DEFAULT CURRENT_TIMESTAMP(),
+  publisher       VARCHAR(64) NOT NULL,
+  consumer        VARCHAR(64)     NULL,
+  hub             VARCHAR(64)     NULL,
+  consumed_hub    DATETIME        NULL,
+  consumed_spoke  DATETIME        NULL,
+  success         DATETIME        NULL,
+  failed          DATETIME        NULL,
+  orphan          DATETIME        NULL,
+
+  PRIMARY KEY (event_id),
+  FOREIGN KEY (hub)       REFERENCES hub    (id),
+  FOREIGN KEY (event_id)  REFERENCES event  (id)
+    ON UPDATE CASCADE
+    ON DELETE CASCADE,
+  INDEX idx_published       (published),
+  INDEX idx_consumed_hub    (consumed_hub),
+  INDEX idx_consumed_spoke  (consumed_spoke)
+)
+ENGINE=InnoDB

package/sql/event_published/update-to-consumed-by-hub.sql

@@ -0,0 +1,5 @@
+UPDATE event_published
+SET consumed_hub = UTC_TIMESTAMP(),
+    hub          = ?
+WHERE event_id   = ?
+  AND consumed_hub IS NULL

package/sql/event_published/update-to-consumed-by-spoke.sql

@@ -0,0 +1,5 @@
+UPDATE event_published
+SET consumed_spoke  = UTC_TIMESTAMP(),
+    consumer        = ?
+WHERE event_id      = ?
+  AND consumed_spoke  IS NULL

package/sql/event_published/update-to-failed.sql

@@ -0,0 +1,3 @@
+UPDATE event_published
+SET failed     = UTC_TIMESTAMP()
+WHERE event_id = ?

package/sql/event_published/update-to-orphan.sql

@@ -0,0 +1,3 @@
+UPDATE event_published
+SET orphan     = UTC_TIMESTAMP()
+WHERE event_id = ?

package/sql/event_published/update-to-success.sql

@@ -0,0 +1,3 @@
+UPDATE event_published
+SET success    = UTC_TIMESTAMP()
+WHERE event_id = ?

package/sql/event_scheduled/persist.sql

@@ -0,0 +1,3 @@
+INSERT
+INTO event_scheduled
+SET ?

package/sql/event_scheduled/read.sql

@@ -0,0 +1,4 @@
+SELECT *
+FROM event_scheduled
+WHERE scheduled >= UTC_TIMESTAMP()
+  AND executed IS NULL

package/sql/event_scheduled/schema.sql

@@ -0,0 +1,20 @@
+CREATE TABLE IF NOT EXISTS event_scheduled 
+(
+  event_id    VARCHAR(64) NOT NULL,
+  timestamp   DATETIME    NOT NULL DEFAULT CURRENT_TIMESTAMP(),
+  scheduled   DATETIME    NOT NULL,
+  executed    DATETIME        NULL,
+  success     DATETIME        NULL,
+  failed      DATETIME        NULL,
+
+  PRIMARY KEY (event_id),
+  FOREIGN KEY (event_id) REFERENCES event (id)
+    ON UPDATE CASCADE
+    ON DELETE CASCADE,
+  INDEX idx_timestamp   (timestamp),
+  INDEX idx_scheduled   (scheduled),
+  INDEX idx_executed    (executed),
+  INDEX idx_success     (success),
+  INDEX idx_failed      (failed)
+)
+ENGINE=InnoDB

package/sql/event_scheduled/update-executed.sql

@@ -0,0 +1,3 @@
+UPDATE event_scheduled
+SET executed   = UTC_TIMESTAMP()
+WHERE event_id = ?

package/sql/event_scheduled/update-failed.sql

@@ -0,0 +1,3 @@
+UPDATE event_scheduled
+SET failed     = UTC_TIMESTAMP()
+WHERE event_id = ?

package/sql/event_scheduled/update-success.sql

@@ -0,0 +1,3 @@
+UPDATE event_scheduled
+SET success    = UTC_TIMESTAMP()
+WHERE event_id = ?

package/sql/hub/persist.sql

@@ -0,0 +1,3 @@
+INSERT
+INTO hub
+SET ?

package/sql/hub/read-online-hubs.sql

@@ -0,0 +1,3 @@
+SELECT *
+FROM hub
+WHERE quit IS NULL

package/sql/hub/schema.sql

@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS hub 
+(
+  id            VARCHAR(64)       NOT NULL,
+  timestamp     DATETIME          NOT NULL DEFAULT CURRENT_TIMESTAMP(),
+  external_ip   VARCHAR(16)       NOT NULL,
+  external_port SMALLINT UNSIGNED NOT NULL,
+  internal_ip   VARCHAR(16)       NOT NULL,
+  internal_port SMALLINT UNSIGNED NOT NULL,
+  quit          DATETIME              NULL,
+
+  PRIMARY KEY (id),
+  INDEX idx_timestamp (timestamp),
+  INDEX idx_external_ip_port (external_ip, external_port),
+  INDEX idx_internal_ip_port (internal_ip, internal_port)
+)
+ENGINE=InnoDB

package/sql/hub/update-to-quit.sql

@@ -0,0 +1,3 @@
+UPDATE hub
+SET quit = UTC_TIMESTAMP()
+WHERE id = ?

package/sql/log/archive.sql

@@ -0,0 +1,5 @@
+ALTER TABLE log REORGANIZE PARTITION p_hot INTO 
+(
+  PARTITION p_cold_?? VALUES LESS THAN (TO_DAYS(?)),
+  PARTITION p_hot     VALUES LESS THAN MAXVALUE
+)

package/sql/log/persist.sql

@@ -0,0 +1,3 @@
+INSERT
+INTO log
+SET ?

package/sql/log/schema.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS log 
+(
+  timestamp DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+  agent     VARCHAR(64) NOT NULL,
+  message   TEXT        NOT NULL,
+  error     JSON        NOT NULL,
+  INDEX idx_timestamp (timestamp),
+  INDEX idx_agent (agent)
+)
+ENGINE=InnoDB
+PARTITION BY RANGE (TO_DAYS(timestamp)) 
+(
+  PARTITION p_hot VALUES LESS THAN MAXVALUE
+)