signalk-chiplog 1.0.0

package/lib/api.js

@@ -0,0 +1,427 @@
+const { getSchemaVersion } = require('./database');
+const { ApiError, badRequest, conflict } = require('./errors');
+const entries = require('./entries');
+const events = require('./events');
+const { renderExport } = require('./export');
+const { toGeoJson, toGpx } = require('./formats');
+const manoeuvreTypes = require('./manoeuvre-types');
+const places = require('./places');
+const propulsion = require('./propulsion');
+const track = require('./track');
+const v = require('./validation');
+
+const SQLITE_CONSTRAINT = 19;
+
+// Servers predating router.access() only support admin-only plugin routes.
+// Falling back keeps the plugin usable there, at the cost of an admin login.
+function scoped(router, level) {
+  return typeof router.access === 'function' ? router.access(level) : router;
+}
+
+function sendError(res, err, logError) {
+  if (err instanceof ApiError) {
+    res.status(err.status).json({ error: { code: err.code, message: err.message } });
+    return;
+  }
+  // Extended SQLite codes carry the primary code in their low byte.
+  if (err.code === 'ERR_SQLITE_ERROR' && (err.errcode & 0xff) === SQLITE_CONSTRAINT) {
+    res.status(409).json({ error: { code: 'constraint_violation', message: err.message } });
+    return;
+  }
+  logError(err);
+  res
+    .status(500)
+    .json({ error: { code: 'internal_error', message: 'Unexpected error, see the server log' } });
+}
+
+function optional(body, field, parse) {
+  return field in body ? parse(body[field], field) : undefined;
+}
+
+function withoutUndefined(object) {
+  return Object.fromEntries(Object.entries(object).filter(([, value]) => value !== undefined));
+}
+
+function parsePayload(value, name) {
+  if (value !== null && !v.isPlainObject(value)) {
+    throw badRequest(`${name} must be a JSON object or null`);
+  }
+  return value;
+}
+
+function parseBoolean(value, name) {
+  if (typeof value !== 'boolean') {
+    throw badRequest(`${name} must be a boolean`);
+  }
+  return value;
+}
+
+function parseInteger(value, name) {
+  if (!Number.isInteger(value)) {
+    throw badRequest(`${name} must be an integer`);
+  }
+  return value;
+}
+
+const nullableString = (maxLength) => (value, name) =>
+  v.parseString(value, name, { maxLength, allowNull: true });
+
+const requiredString = (maxLength) => (value, name) => v.parseString(value, name, { maxLength });
+
+function parseRange(query) {
+  return {
+    from: v.parseOptionalTimestamp(query.from, 'from'),
+    to: v.parseOptionalTimestamp(query.to, 'to')
+  };
+}
+
+function registerRoutes(router, { getContext, logError }) {
+  const readonly = scoped(router, 'readonly');
+  const readwrite = scoped(router, 'readwrite');
+  const admin = router;
+
+  const handle = (fn) => async (req, res) => {
+    try {
+      const body = await fn(getContext(), req, res);
+      if (!res.headersSent) {
+        if (body === undefined) {
+          res.status(204).end();
+        } else {
+          res.json(body);
+        }
+      }
+    } catch (err) {
+      sendError(res, err, logError);
+    }
+  };
+
+  const entryId = (req) => v.parseId(req.params.id);
+
+  readonly.get(
+    '/api/state',
+    handle(({ db, detection }) => {
+      const { mode, motion, propulsion: under, stateIssue } = detection();
+      return {
+        activeEntryId:
+          db.prepare("SELECT id FROM log_entries WHERE state = 'active'").get()?.id ?? null,
+        detection: mode,
+        motion,
+        propulsion: under,
+        stateIssue,
+        schemaVersion: getSchemaVersion(db)
+      };
+    })
+  );
+
+  // Entries
+
+  readonly.get(
+    '/api/entries',
+    handle(({ db }, req) =>
+      entries.listEntries(db, { ...parseRange(req.query), ...v.parsePagination(req.query) })
+    )
+  );
+
+  readonly.get(
+    '/api/entries/:id',
+    handle(({ db }, req) => entries.getEntry(db, entryId(req)))
+  );
+
+  readwrite.patch(
+    '/api/entries/:id',
+    handle(({ db, config, now }, req) => {
+      const id = entryId(req);
+      const body = v.requireBody(req.body, [
+        'startTime',
+        'endTime',
+        'startPosition',
+        'endPosition',
+        'startPlaceName',
+        'endPlaceName',
+        'distance'
+      ]);
+      const patch = {
+        startTime: optional(body, 'startTime', v.parseTimestamp),
+        endTime: optional(body, 'endTime', v.parseTimestamp),
+        startPosition: optional(body, 'startPosition', v.parsePosition),
+        endPosition: optional(body, 'endPosition', v.parsePosition),
+        startPlaceName: optional(body, 'startPlaceName', nullableString(200)),
+        endPlaceName: optional(body, 'endPlaceName', nullableString(200)),
+        distance: optional(body, 'distance', v.parseNonNegativeNumber)
+      };
+      return entries.updateEntry(db, id, patch, {
+        placeMatchRadius: config.placeMatchRadius,
+        now: now()
+      });
+    })
+  );
+
+  readwrite.post(
+    '/api/entries/:id/close',
+    handle(({ db, config, now, vesselPosition }, req) =>
+      entries.closeEntry(db, entryId(req), {
+        now: now(),
+        position: vesselPosition(),
+        placeMatchRadius: config.placeMatchRadius
+      })
+    )
+  );
+
+  readwrite.post(
+    '/api/entries/:id/merge',
+    handle(({ db, now }, req) => {
+      const id = entryId(req);
+      const body = v.requireBody(req.body, ['withEntryId']);
+      return entries.mergeEntries(db, id, v.parseId(body.withEntryId, 'withEntryId'), now());
+    })
+  );
+
+  admin.delete(
+    '/api/entries/:id',
+    handle(({ db }, req) => {
+      entries.deleteEntry(db, entryId(req));
+    })
+  );
+
+  // Track, observations, propulsion
+
+  readonly.get(
+    '/api/entries/:id/track',
+    handle(({ db }, req, res) => {
+      const id = entryId(req);
+      const format = v.parseEnum(req.query.format ?? 'geojson', 'format', ['geojson', 'gpx']);
+      const entry = entries.getEntry(db, id);
+      const trackPoints = track.allTrackPoints(db, id);
+      if (format === 'gpx') {
+        res.type('application/gpx+xml').send(toGpx([{ entry, trackPoints }]));
+        return null;
+      }
+      return toGeoJson(entry, trackPoints);
+    })
+  );
+
+  readonly.get(
+    '/api/entries/:id/observations',
+    handle(({ db }, req) => track.listObservations(db, entryId(req), v.parsePagination(req.query)))
+  );
+
+  readonly.get(
+    '/api/entries/:id/propulsion',
+    handle(({ db }, req) => propulsion.listSegments(db, entryId(req), v.parsePagination(req.query)))
+  );
+
+  readwrite.patch(
+    '/api/propulsion/:id',
+    handle(({ db, now }, req) => {
+      const id = v.parseId(req.params.id);
+      const body = v.requireBody(req.body, ['type']);
+      const type = v.parseEnum(body.type, 'type', ['engine', 'sail']);
+      return propulsion.correctSegment(db, id, { type }, { now: now() });
+    })
+  );
+
+  // Events
+
+  readonly.get(
+    '/api/entries/:id/events',
+    handle(({ db }, req) =>
+      events.listEvents(db, entryId(req), {
+        type:
+          req.query.type === undefined
+            ? undefined
+            : v.parseEnum(req.query.type, 'type', events.EVENT_TYPES),
+        ...v.parsePagination(req.query)
+      })
+    )
+  );
+
+  const EVENT_FIELDS = ['type', 'subtype', 'comment', 'payload', 'time', 'position', 'clientRef'];
+
+  const parseEventInput = (body) => ({
+    type: v.parseEnum(body.type, 'type', events.CLIENT_EVENT_TYPES),
+    subtype: optional(body, 'subtype', nullableString(200)),
+    comment: optional(body, 'comment', nullableString(10000)),
+    payload: optional(body, 'payload', parsePayload),
+    time: optional(body, 'time', v.parseTimestamp),
+    position: optional(body, 'position', v.parsePosition),
+    clientRef: optional(body, 'clientRef', requiredString(100))
+  });
+
+  // Conditions at a manoeuvre belong in the log — but only as it happens;
+  // readings now say nothing about a manoeuvre logged after the fact.
+  const observeLiveManoeuvre = (observeEvent, input, { event, created }) => {
+    if (created && event.type === 'manoeuvre' && input.time === undefined) {
+      observeEvent(event.entryId, event.time);
+    }
+  };
+
+  readwrite.post(
+    '/api/entries/:id/events',
+    handle(({ db, now, vesselPosition, observeEvent }, req, res) => {
+      const id = entryId(req);
+      const input = parseEventInput(v.requireBody(req.body, EVENT_FIELDS));
+      const outcome = events.createEvent(db, id, input, {
+        now: now(),
+        vesselPosition: vesselPosition()
+      });
+      observeLiveManoeuvre(observeEvent, input, outcome);
+      res.status(outcome.created ? 201 : 200);
+      return outcome.event;
+    })
+  );
+
+  // What the tablet posts: the server finds the passage the entry belongs to.
+  readwrite.post(
+    '/api/events',
+    handle(({ db, config, now, vesselPosition, observeEvent }, req, res) => {
+      const input = parseEventInput(v.requireBody(req.body, EVENT_FIELDS));
+      const outcome = events.logCrewEvent(db, input, {
+        now: now(),
+        vesselPosition: vesselPosition(),
+        placeMatchRadius: config.placeMatchRadius
+      });
+      observeLiveManoeuvre(observeEvent, input, outcome);
+      res.status(outcome.created ? 201 : 200);
+      return { ...outcome.event, openedEntry: outcome.openedEntry };
+    })
+  );
+
+  readwrite.patch(
+    '/api/events/:id',
+    handle(({ db }, req) => {
+      const id = v.parseId(req.params.id);
+      const body = v.requireBody(req.body, ['time', 'comment', 'subtype', 'payload']);
+      const patch = withoutUndefined({
+        time: optional(body, 'time', v.parseTimestamp),
+        comment: optional(body, 'comment', nullableString(10000)),
+        subtype: optional(body, 'subtype', nullableString(200)),
+        payload: optional(body, 'payload', parsePayload)
+      });
+      return events.updateEvent(db, id, patch);
+    })
+  );
+
+  readwrite.delete(
+    '/api/events/:id',
+    handle(({ db }, req) => {
+      events.deleteEvent(db, v.parseId(req.params.id));
+    })
+  );
+
+  // Places
+
+  readonly.get(
+    '/api/places',
+    handle(({ db }, req) => places.listPlaces(db, v.parsePagination(req.query)))
+  );
+
+  readwrite.patch(
+    '/api/places/:id',
+    handle(({ db, now }, req) => {
+      const id = v.parseId(req.params.id);
+      const body = v.requireBody(req.body, ['name']);
+      return places.renamePlace(
+        db,
+        id,
+        v.parseString(body.name, 'name', { maxLength: 200 }),
+        now()
+      );
+    })
+  );
+
+  admin.delete(
+    '/api/places/:id',
+    handle(({ db }, req) => {
+      places.deletePlace(db, v.parseId(req.params.id));
+    })
+  );
+
+  // Manoeuvre shortcuts
+
+  readonly.get(
+    '/api/manoeuvre-types',
+    handle(({ db }, req) => manoeuvreTypes.listManoeuvreTypes(db, v.parsePagination(req.query)))
+  );
+
+  admin.post(
+    '/api/manoeuvre-types',
+    handle(({ db }, req, res) => {
+      const body = v.requireBody(req.body, ['key', 'label', 'icon', 'sortOrder', 'enabled']);
+      const type = manoeuvreTypes.createManoeuvreType(db, {
+        key: v.parseString(body.key, 'key', { maxLength: 40 }),
+        label: v.parseString(body.label, 'label', { maxLength: 100 }),
+        icon: optional(body, 'icon', nullableString(100)),
+        sortOrder: optional(body, 'sortOrder', parseInteger),
+        enabled: optional(body, 'enabled', parseBoolean)
+      });
+      res.status(201);
+      return type;
+    })
+  );
+
+  admin.patch(
+    '/api/manoeuvre-types/:key',
+    handle(({ db }, req) => {
+      const body = v.requireBody(req.body, ['label', 'icon', 'sortOrder', 'enabled']);
+      return manoeuvreTypes.updateManoeuvreType(db, req.params.key, {
+        label: optional(body, 'label', requiredString(100)),
+        icon: optional(body, 'icon', nullableString(100)),
+        sortOrder: optional(body, 'sortOrder', parseInteger),
+        enabled: optional(body, 'enabled', parseBoolean)
+      });
+    })
+  );
+
+  admin.delete(
+    '/api/manoeuvre-types/:key',
+    handle(({ db }, req) => {
+      manoeuvreTypes.deleteManoeuvreType(db, req.params.key);
+    })
+  );
+
+  // Export
+
+  readonly.get(
+    '/api/export',
+    handle(({ db, now }, req, res) => {
+      const format = v.parseEnum(req.query.format ?? 'json', 'format', [
+        'json',
+        'csv',
+        'gpx',
+        'pdf'
+      ]);
+      if (format === 'pdf') {
+        throw new ApiError(501, 'not_implemented', 'PDF export arrives in V1.1');
+      }
+      const { contentType, filename, body } = renderExport(
+        db,
+        format,
+        parseRange(req.query),
+        now()
+      );
+      res.attachment(filename).type(contentType).send(body);
+      return null;
+    })
+  );
+
+  readonly.get(
+    '/api/export/usb',
+    handle(({ config, usbExport }) => ({ directory: config.usbExportPath, ...usbExport.status() }))
+  );
+
+  // Goes through the scheduler, so it never overlaps an automatic copy.
+  admin.post(
+    '/api/export/usb',
+    handle(({ config, usbExport }) => {
+      if (!config.usbExportPath) {
+        throw conflict(
+          'usb_export_not_configured',
+          'Set the USB export directory in the plugin configuration first'
+        );
+      }
+      return usbExport.run('manual');
+    })
+  );
+}
+
+module.exports = { registerRoutes };

package/lib/database.js

@@ -0,0 +1,264 @@
+const path = require('node:path');
+const { DatabaseSync } = require('node:sqlite');
+
+const DATABASE_FILENAME = 'chiplog.sqlite';
+
+// Manoeuvre shortcuts shipped with the plugin (SPEC §4.3). Users may disable or
+// reorder them and add their own; a later migration adds new built-in ones.
+const BUILTIN_MANOEUVRE_TYPES = [
+  ['tack', 'Tack', 10],
+  ['gybe', 'Gybe', 20],
+  ['reef_in', 'Reef in', 30],
+  ['reef_out', 'Shake out reef', 40],
+  ['sail_change', 'Sail change', 50],
+  ['anchor_down', 'Anchor down', 60],
+  ['anchor_up', 'Anchor up', 70],
+  ['moor', 'Moor', 80],
+  ['cast_off', 'Cast off', 90],
+  ['watch_change', 'Watch change', 100]
+];
+
+// Append-only: each entry is applied once, in order, and its index becomes the
+// database's user_version. Never edit or reorder an already-released migration.
+const MIGRATIONS = [
+  `
+  -- Units follow Signal K: angles in radians, speeds in m/s, distances in
+  -- metres, durations in seconds, pressure in Pa, temperatures in K.
+  -- Timestamps are ISO 8601 UTC text with millisecond precision.
+
+  CREATE TABLE places (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    lat REAL NOT NULL,
+    lon REAL NOT NULL,
+    source TEXT NOT NULL CHECK (source IN ('geocoding', 'manual')),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  -- Supports the bounding-box prefilter of the radius match; the exact
+  -- distance test then runs in application code.
+  CREATE INDEX idx_places_position ON places (lat, lon);
+
+  CREATE TABLE log_entries (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    state TEXT NOT NULL DEFAULT 'active' CHECK (state IN ('active', 'closed')),
+    start_time TEXT NOT NULL,
+    end_time TEXT,
+    -- Set when the vessel stops, cleared if it moves again before the
+    -- configured tolerance elapses (SPEC §3.1).
+    stopped_since TEXT,
+    start_lat REAL,
+    start_lon REAL,
+    end_lat REAL,
+    end_lon REAL,
+    start_place_id INTEGER REFERENCES places (id) ON DELETE SET NULL,
+    end_place_id INTEGER REFERENCES places (id) ON DELETE SET NULL,
+    -- Denormalised on purpose: the logbook records the name as it stood at the
+    -- time, so renaming a place later must not rewrite past entries.
+    start_place_name TEXT,
+    end_place_name TEXT,
+    distance REAL NOT NULL DEFAULT 0,
+    engine_duration INTEGER NOT NULL DEFAULT 0,
+    sail_duration INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    CHECK (end_time IS NULL OR end_time >= start_time),
+    CHECK (state = 'active' OR end_time IS NOT NULL)
+  );
+
+  CREATE INDEX idx_log_entries_start_time ON log_entries (start_time);
+
+  -- One vessel per instance, passages are sequential: at most one open entry.
+  CREATE UNIQUE INDEX idx_log_entries_single_active
+    ON log_entries (state) WHERE state = 'active';
+
+  -- Dense geometry for the map and the GPX export (SPEC §4.1). Deliberately
+  -- narrow: instrument readings live in observations instead.
+  CREATE TABLE track_points (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_id INTEGER NOT NULL REFERENCES log_entries (id) ON DELETE CASCADE,
+    time TEXT NOT NULL,
+    lat REAL NOT NULL,
+    lon REAL NOT NULL,
+    sog REAL,
+    cog REAL
+  );
+
+  CREATE INDEX idx_track_points_entry_time ON track_points (entry_id, time);
+
+  -- Sparse instrument snapshots: the rows the facsimile PDF renders as
+  -- logbook lines (SPEC §4.5). Every reading is nullable, since a boat may
+  -- lack any given sensor (SPEC §4.7).
+  CREATE TABLE observations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_id INTEGER NOT NULL REFERENCES log_entries (id) ON DELETE CASCADE,
+    time TEXT NOT NULL,
+    reason TEXT NOT NULL CHECK (reason IN ('periodic', 'entry_start', 'entry_end', 'event')),
+    lat REAL,
+    lon REAL,
+    sog REAL,
+    cog REAL,
+    heading REAL,
+    stw REAL,
+    twd REAL,
+    tws REAL,
+    awa REAL,
+    aws REAL,
+    depth REAL,
+    pressure REAL,
+    air_temp REAL,
+    water_temp REAL,
+    trip_log REAL,
+    engine_runtime REAL
+  );
+
+  CREATE INDEX idx_observations_entry_time ON observations (entry_id, time);
+
+  CREATE TABLE propulsion_segments (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_id INTEGER NOT NULL REFERENCES log_entries (id) ON DELETE CASCADE,
+    type TEXT NOT NULL CHECK (type IN ('engine', 'sail')),
+    start_time TEXT NOT NULL,
+    end_time TEXT,
+    -- 'manual' once a user correction has overridden the detection (SPEC §4.2).
+    source TEXT NOT NULL DEFAULT 'auto' CHECK (source IN ('auto', 'manual')),
+    average_rpm REAL,
+    CHECK (end_time IS NULL OR end_time >= start_time)
+  );
+
+  CREATE INDEX idx_propulsion_segments_entry_time
+    ON propulsion_segments (entry_id, start_time);
+
+  CREATE TABLE events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_id INTEGER NOT NULL REFERENCES log_entries (id) ON DELETE CASCADE,
+    time TEXT NOT NULL,
+    type TEXT NOT NULL CHECK (
+      type IN (
+        'manoeuvre',
+        'text_annotation',
+        'handwritten_annotation',
+        'sk_alarm',
+        'autopilot',
+        'weather_threshold',
+        'manual_correction'
+      )
+    ),
+    -- Qualifies the type: manoeuvre key, Signal K notification path, autopilot
+    -- state. Intentionally not a foreign key, so history survives a manoeuvre
+    -- type being deleted.
+    subtype TEXT,
+    lat REAL,
+    lon REAL,
+    comment TEXT,
+    -- JSON, for structured detail only: handwritten strokes, sail selection,
+    -- the before/after of a correction.
+    payload TEXT,
+    source TEXT NOT NULL DEFAULT 'manual' CHECK (source IN ('auto', 'manual')),
+    created_at TEXT NOT NULL
+  );
+
+  CREATE INDEX idx_events_entry_time ON events (entry_id, time);
+  CREATE INDEX idx_events_type ON events (type);
+
+  CREATE TABLE manoeuvre_types (
+    key TEXT PRIMARY KEY,
+    label TEXT NOT NULL,
+    icon TEXT,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    builtin INTEGER NOT NULL DEFAULT 0 CHECK (builtin IN (0, 1)),
+    enabled INTEGER NOT NULL DEFAULT 1 CHECK (enabled IN (0, 1))
+  );
+  `,
+  `
+  -- Last time passage detection saw the vessel moving, refreshed about once a
+  -- minute while under way. After a restart it dates the end of a passage that
+  -- stopped while the plugin was not running.
+  ALTER TABLE log_entries ADD COLUMN last_moving_at TEXT;
+  `,
+  `
+  -- A place name generated from coordinates while online geocoding has not
+  -- yet answered for that departure or arrival. Cleared once resolved, or as
+  -- soon as someone types a name.
+  ALTER TABLE log_entries ADD COLUMN start_place_pending INTEGER NOT NULL DEFAULT 0
+    CHECK (start_place_pending IN (0, 1));
+  ALTER TABLE log_entries ADD COLUMN end_place_pending INTEGER NOT NULL DEFAULT 0
+    CHECK (end_place_pending IN (0, 1));
+  `,
+  `
+  -- The departure manoeuvre (cast off, anchor up) that opened this passage by
+  -- hand before the vessel moved. Undoing that manoeuvre before any movement
+  -- removes the passage with it.
+  ALTER TABLE log_entries ADD COLUMN opened_by_event_id INTEGER
+    REFERENCES events (id) ON DELETE SET NULL;
+
+  -- Idempotency key chosen by the client, so an entry replayed from the
+  -- tablet's offline queue after a lost response is not logged twice.
+  ALTER TABLE events ADD COLUMN client_ref TEXT;
+  CREATE UNIQUE INDEX idx_events_client_ref ON events (client_ref)
+    WHERE client_ref IS NOT NULL;
+
+  -- Finds the vessel's position at the time of an entry logged after the fact,
+  -- before knowing which passage it belongs to.
+  CREATE INDEX idx_track_points_time ON track_points (time);
+  `
+];
+
+function seedBuiltinManoeuvreTypes(db) {
+  const insert = db.prepare(
+    `INSERT INTO manoeuvre_types (key, label, sort_order, builtin)
+     VALUES (?, ?, ?, 1)
+     ON CONFLICT (key) DO NOTHING`
+  );
+  for (const [key, label, sortOrder] of BUILTIN_MANOEUVRE_TYPES) {
+    insert.run(key, label, sortOrder);
+  }
+}
+
+function withTransaction(db, fn) {
+  db.exec('BEGIN');
+  try {
+    const result = fn();
+    db.exec('COMMIT');
+    return result;
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  }
+}
+
+function getSchemaVersion(db) {
+  return db.prepare('PRAGMA user_version').get().user_version;
+}
+
+function migrate(db) {
+  const currentVersion = getSchemaVersion(db);
+
+  for (let version = currentVersion; version < MIGRATIONS.length; version += 1) {
+    withTransaction(db, () => {
+      db.exec(MIGRATIONS[version]);
+      if (version === 0) {
+        seedBuiltinManoeuvreTypes(db);
+      }
+      db.exec(`PRAGMA user_version = ${version + 1}`);
+    });
+  }
+
+  return { from: currentVersion, to: MIGRATIONS.length };
+}
+
+function openDatabase(dataDirPath) {
+  const db = new DatabaseSync(path.join(dataDirPath, DATABASE_FILENAME));
+
+  // WAL keeps reads working while a passage is being written, and survives
+  // the abrupt power cuts a boat installation gets.
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA foreign_keys = ON');
+
+  const migrated = migrate(db);
+
+  return { db, migrated };
+}
+
+module.exports = { openDatabase, withTransaction, getSchemaVersion, DATABASE_FILENAME };