@signalk/tracks-plugin 3.1.1 → 3.2.0

package/dist/trackStoreWorker.js

@@ -1,4 +1,4 @@
-import { c as createMatcher, n as SelfPositionUnavailableError, p as splitAtAntimeridian, s as createInBounds, x as thin } from "./utils-CGIGp4Xf.js";
+import { S as thin, c as createMatcher, d as longitudeSpan, m as splitAtAntimeridian, n as SelfPositionUnavailableError, s as createInBounds } from "./utils-C0VkiidM.js";
 import { parentPort, workerData } from "node:worker_threads";
 import { DatabaseSync } from "node:sqlite";
 //#region \0rolldown/runtime.js
@@ -11305,6 +11305,11 @@ var coveringFor = (bounds, maxCells) => {
 		});
 	});
 };
+/** Longitude intervals as `[west, east]`, either of which may cross the antimeridian. */
+var longitudesOverlap = (a, b) => {
+	const pieces = ([west, east]) => west <= east ? [[west, east]] : [[west, 180], [-180, east]];
+	return pieces(a).some(([aWest, aEast]) => pieces(b).some(([bWest, bEast]) => aWest <= bEast && bWest <= aEast));
+};
 var DEFAULT_MAX_CELLS = 8;
 var DEFAULT_SEGMENT_GAP = 3e5;
 /**
@@ -11330,9 +11335,11 @@ var SqliteTrackStore = class {
 	insert;
 	insertName;
 	selectName;
+	selectImportedPoints;
 	maxCells;
 	segmentGap;
 	retention;
+	binRetention;
 	resolution;
 	/** See CLIP_STRETCH_GAP; widened so a coarse write resolution does not split every fix. */
 	stretchGap;
@@ -11349,6 +11356,7 @@ var SqliteTrackStore = class {
 		this.maxCells = config.maxCells ?? DEFAULT_MAX_CELLS;
 		this.segmentGap = config.segmentGap ?? DEFAULT_SEGMENT_GAP;
 		this.retention = config.retention ?? 0;
+		this.binRetention = config.binRetention ?? 0;
 		this.resolution = config.resolution ?? 0;
 		this.stretchGap = Math.max(CLIP_STRETCH_GAP, 2 * this.resolution);
 		this.debug = debug;
@@ -11374,12 +11382,85 @@ var SqliteTrackStore = class {
         name      TEXT NOT NULL,
         timestamp INTEGER NOT NULL
       );
+      -- Imported tracks, apart from positions: they are never merged into a
+      -- recording or pruned with one. The extent is kept per track so a query
+      -- can skip an import without reading its points.
+      CREATE TABLE IF NOT EXISTS imported_tracks (
+        id          TEXT PRIMARY KEY,
+        context     TEXT,
+        name        TEXT,
+        metadata    TEXT    NOT NULL,
+        first_time  INTEGER,
+        last_time   INTEGER,
+        west        REAL    NOT NULL,
+        south       REAL    NOT NULL,
+        east        REAL    NOT NULL,
+        north       REAL    NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_imported_context ON imported_tracks(context);
+      CREATE TABLE IF NOT EXISTS imported_points (
+        track_id  TEXT    NOT NULL,
+        seq       INTEGER NOT NULL,
+        segment   INTEGER NOT NULL,
+        timestamp INTEGER,
+        lat       REAL    NOT NULL,
+        lon       REAL    NOT NULL,
+        PRIMARY KEY (track_id, seq)
+      ) WITHOUT ROWID;
+      -- The recycle bin. A delete moves rows here rather than removing them,
+      -- so the tables every read uses stay as they are and a restore moves
+      -- them back. A purged recorded span keeps its row: a history provider
+      -- would otherwise fill the deleted window back in.
+      CREATE TABLE IF NOT EXISTS recycle_bin (
+        id          INTEGER PRIMARY KEY,
+        context     TEXT,
+        import_id   TEXT,
+        name        TEXT,
+        whole       INTEGER NOT NULL,
+        span_from   INTEGER,
+        span_to     INTEGER,
+        deleted_at  INTEGER NOT NULL,
+        purged      INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS binned_positions (
+        bin_id    INTEGER NOT NULL,
+        context   TEXT    NOT NULL,
+        timestamp INTEGER NOT NULL,
+        lat       REAL    NOT NULL,
+        lon       REAL    NOT NULL,
+        s2cell    INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_binned_positions ON binned_positions(bin_id);
+      CREATE TABLE IF NOT EXISTS binned_imported_tracks (
+        bin_id      INTEGER PRIMARY KEY,
+        id          TEXT    NOT NULL,
+        context     TEXT,
+        name        TEXT,
+        metadata    TEXT    NOT NULL,
+        first_time  INTEGER,
+        last_time   INTEGER,
+        west        REAL    NOT NULL,
+        south       REAL    NOT NULL,
+        east        REAL    NOT NULL,
+        north       REAL    NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS binned_imported_points (
+        bin_id    INTEGER NOT NULL,
+        track_id  TEXT    NOT NULL,
+        seq       INTEGER NOT NULL,
+        segment   INTEGER NOT NULL,
+        timestamp INTEGER,
+        lat       REAL    NOT NULL,
+        lon       REAL    NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_binned_imported_points ON binned_imported_points(bin_id);
     `);
 		this.insert = this.db.prepare("INSERT INTO positions (context, timestamp, lat, lon, s2cell) VALUES (?, ?, ?, ?, ?)");
 		this.insertName = this.db.prepare(`INSERT INTO names (context, name, timestamp) VALUES (?, ?, ?)
        ON CONFLICT(context) DO UPDATE SET name = excluded.name, timestamp = excluded.timestamp
        WHERE excluded.timestamp >= names.timestamp`);
 		this.selectName = this.db.prepare("SELECT name FROM names WHERE context = ?");
+		this.selectImportedPoints = this.db.prepare("SELECT segment, timestamp, lat, lon FROM imported_points WHERE track_id = ? ORDER BY seq");
 	}
 	newPosition(context, position, timestamp = Date.now()) {
 		if (this.resolution > 0) {
@@ -11594,12 +11675,244 @@ var SqliteTrackStore = class {
 			this.lastName.delete(context);
 		}
 		for (const { context } of dropped) this.lastStored.delete(context);
+		if (this.binRetention > 0) {
+			const expired = this.db.prepare("SELECT * FROM recycle_bin WHERE purged = 0 AND deleted_at < ? ORDER BY whole DESC").all(now - this.binRetention);
+			for (const entry of expired) if (this.liveEntry(entry.id)) this.purge(entry);
+		}
 		if (this.retention > 0) {
 			const oldest = now - this.retention;
 			if (keep === void 0) this.db.prepare("DELETE FROM positions WHERE timestamp < ?").run(oldest);
 			else this.db.prepare("DELETE FROM positions WHERE timestamp < ? AND context IS ?").run(oldest, keep);
 		}
 	}
+	/**
+	* Keep an imported track. The caller mints the id; a second track under the
+	* same id fails rather than replacing the first.
+	*/
+	storeImport(track) {
+		const points = track.segments.flat();
+		if (points.length === 0) throw new Error("An imported track needs at least one point");
+		let south = points[0].position[0];
+		let north = south;
+		let firstTime;
+		let lastTime;
+		for (const { position, timestamp } of points) {
+			south = Math.min(south, position[0]);
+			north = Math.max(north, position[0]);
+			if (timestamp !== void 0) {
+				firstTime = firstTime === void 0 ? timestamp : Math.min(firstTime, timestamp);
+				lastTime = lastTime === void 0 ? timestamp : Math.max(lastTime, timestamp);
+			}
+		}
+		const [west, east] = longitudeSpan(points.map(({ position }) => position[1]));
+		this.db.prepare(`INSERT INTO imported_tracks (id, context, name, metadata, first_time, last_time, west, south, east, north)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(track.id, track.context ?? null, track.name ?? null, JSON.stringify(track.metadata), firstTime ?? null, lastTime ?? null, west, south, east, north);
+		const insert = this.db.prepare("INSERT INTO imported_points (track_id, seq, segment, timestamp, lat, lon) VALUES (?, ?, ?, ?, ?, ?)");
+		let seq = 0;
+		for (const [segment, segmentPoints] of track.segments.entries()) for (const { position, timestamp } of segmentPoints) insert.run(track.id, seq++, segment, timestamp ?? null, position[0], position[1]);
+	}
+	/**
+	* Move a vessel's positions recorded within `[from, to]` into the recycle
+	* bin, resolving to the entry's id and whether the store held the vessel at
+	* all.
+	*
+	* An entry is made even when the store holds nothing there if `keepEmpty`
+	* says another source does: the span still has to hide what a history
+	* provider holds. Without one, an empty delete leaves no entry behind.
+	*/
+	binRecorded(context, from, to, deletedAt, keepEmpty) {
+		const known = this.knows(context);
+		const lower = from ?? Number.MIN_SAFE_INTEGER;
+		const id = this.newBinEntry({
+			context,
+			...from === void 0 ? {} : { from },
+			to,
+			deletedAt
+		});
+		if (Number(this.db.prepare(`INSERT INTO binned_positions (bin_id, context, timestamp, lat, lon, s2cell)
+           SELECT ?, context, timestamp, lat, lon, s2cell FROM positions
+           WHERE context = ? AND timestamp >= ? AND timestamp <= ?`).run(id, context, lower, to).changes) === 0 && !keepEmpty) {
+			this.db.prepare("DELETE FROM recycle_bin WHERE id = ?").run(id);
+			return { known };
+		}
+		this.db.prepare("DELETE FROM positions WHERE context = ? AND timestamp >= ? AND timestamp <= ?").run(context, lower, to);
+		return {
+			id,
+			known
+		};
+	}
+	/**
+	* Move an imported track into the recycle bin, or with a span only its
+	* points within it, resolving to the entry's id; undefined when there is no
+	* such import, or the span holds none of its points.
+	*/
+	binImport(importId, span, deletedAt) {
+		const track = this.db.prepare("SELECT context, name FROM imported_tracks WHERE id = ?").get(importId);
+		if (!track) return;
+		const id = this.newBinEntry({
+			...track.context === null ? {} : { context: track.context },
+			importId,
+			...track.name === null ? {} : { name: track.name },
+			...span ?? {},
+			deletedAt
+		});
+		const where = span ? "track_id = ? AND timestamp >= ? AND timestamp <= ?" : "track_id = ?";
+		const params = span ? [
+			importId,
+			span.from ?? Number.MIN_SAFE_INTEGER,
+			span.to ?? Number.MAX_SAFE_INTEGER
+		] : [importId];
+		const moved = Number(this.db.prepare(`INSERT INTO binned_imported_points (bin_id, track_id, seq, segment, timestamp, lat, lon)
+           SELECT ?, track_id, seq, segment, timestamp, lat, lon FROM imported_points WHERE ${where}`).run(id, ...params).changes);
+		if (span && moved === 0) {
+			this.db.prepare("DELETE FROM recycle_bin WHERE id = ?").run(id);
+			return;
+		}
+		this.db.prepare(`DELETE FROM imported_points WHERE ${where}`).run(...params);
+		const emptied = span && !this.db.prepare("SELECT 1 AS found FROM imported_points WHERE track_id = ?").get(importId);
+		if (emptied) this.db.prepare("UPDATE recycle_bin SET whole = 1, span_from = NULL, span_to = NULL WHERE id = ?").run(id);
+		if (!span || emptied) {
+			this.db.prepare(`INSERT INTO binned_imported_tracks
+           SELECT ?, id, context, name, metadata, first_time, last_time, west, south, east, north
+           FROM imported_tracks WHERE id = ?`).run(id, importId);
+			this.db.prepare("DELETE FROM imported_tracks WHERE id = ?").run(importId);
+		}
+		return id;
+	}
+	newBinEntry(entry) {
+		const whole = entry.importId !== void 0 && entry.from === void 0 && entry.to === void 0;
+		return Number(this.db.prepare(`INSERT INTO recycle_bin (context, import_id, name, whole, span_from, span_to, deleted_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`).run(entry.context ?? null, entry.importId ?? null, entry.name ?? null, whole ? 1 : 0, entry.from ?? null, entry.to ?? null, entry.deletedAt).lastInsertRowid);
+	}
+	/**
+	* Put a recycle bin entry's rows back where they were deleted from.
+	*
+	* A span of an import whose whole track has since gone to the bin as well
+	* is a conflict: its points have no track to return to until that is
+	* restored first.
+	*/
+	restoreFromBin(id) {
+		const entry = this.liveEntry(id);
+		if (!entry) return "missing";
+		if (entry.import_id === null) {
+			this.db.prepare(`INSERT INTO positions (context, timestamp, lat, lon, s2cell)
+           SELECT context, timestamp, lat, lon, s2cell FROM binned_positions WHERE bin_id = ?`).run(id);
+			this.db.prepare("DELETE FROM binned_positions WHERE bin_id = ?").run(id);
+		} else {
+			if (entry.whole === 1) {
+				this.db.prepare(`INSERT INTO imported_tracks (id, context, name, metadata, first_time, last_time, west, south, east, north)
+             SELECT id, context, name, metadata, first_time, last_time, west, south, east, north
+             FROM binned_imported_tracks WHERE bin_id = ?`).run(id);
+				this.db.prepare("DELETE FROM binned_imported_tracks WHERE bin_id = ?").run(id);
+			} else if (!this.db.prepare("SELECT 1 AS found FROM imported_tracks WHERE id = ?").get(entry.import_id)) return "conflict";
+			this.db.prepare(`INSERT INTO imported_points (track_id, seq, segment, timestamp, lat, lon)
+           SELECT track_id, seq, segment, timestamp, lat, lon FROM binned_imported_points WHERE bin_id = ?`).run(id);
+			this.db.prepare("DELETE FROM binned_imported_points WHERE bin_id = ?").run(id);
+		}
+		this.db.prepare("DELETE FROM recycle_bin WHERE id = ?").run(id);
+		return "restored";
+	}
+	/** Purge one recycle bin entry now, resolving whether it was in the bin. */
+	purgeFromBin(id) {
+		const entry = this.liveEntry(id);
+		if (!entry) return false;
+		this.purge(entry);
+		return true;
+	}
+	/** Entries still in the recycle bin, newest delete first. */
+	binEntries() {
+		return this.db.prepare(`SELECT bin.*,
+           (SELECT COUNT(*) FROM binned_positions WHERE bin_id = bin.id)
+           + (SELECT COUNT(*) FROM binned_imported_points WHERE bin_id = bin.id) AS point_count
+         FROM recycle_bin AS bin WHERE purged = 0 ORDER BY deleted_at DESC, id DESC`).all().map((row) => ({
+			id: row.id,
+			...row.context === null ? {} : { context: row.context },
+			...row.import_id === null ? {} : { importId: row.import_id },
+			...row.name === null ? {} : { name: row.name },
+			whole: row.whole === 1,
+			...row.span_from === null ? {} : { from: row.span_from },
+			...row.span_to === null ? {} : { to: row.span_to },
+			deletedAt: row.deleted_at,
+			pointCount: row.point_count
+		}));
+	}
+	/** Every deleted span of a recorded track, purged or not: what history must not show. */
+	deletedSpans() {
+		return this.db.prepare("SELECT context, span_from, span_to FROM recycle_bin WHERE import_id IS NULL").all().map(({ context, span_from, span_to }) => ({
+			context,
+			...span_from === null ? {} : { from: span_from },
+			to: span_to
+		}));
+	}
+	liveEntry(id) {
+		return this.db.prepare("SELECT * FROM recycle_bin WHERE id = ? AND purged = 0").get(id);
+	}
+	/**
+	* Remove an entry's rows for good. A recorded span stays as a tombstone, so
+	* history cannot refill it; a whole import takes the spans deleted from it
+	* earlier with it, since they have no track left to be restored into.
+	*/
+	purge(entry) {
+		const ids = entry.whole === 1 ? this.db.prepare("SELECT id FROM recycle_bin WHERE import_id = ? AND purged = 0").all(entry.import_id).map(({ id }) => id) : [entry.id];
+		for (const id of ids) {
+			this.db.prepare("DELETE FROM binned_positions WHERE bin_id = ?").run(id);
+			this.db.prepare("DELETE FROM binned_imported_points WHERE bin_id = ?").run(id);
+			this.db.prepare("DELETE FROM binned_imported_tracks WHERE bin_id = ?").run(id);
+			if (entry.import_id === null) this.db.prepare("UPDATE recycle_bin SET purged = 1 WHERE id = ?").run(id);
+			else this.db.prepare("DELETE FROM recycle_bin WHERE id = ?").run(id);
+		}
+	}
+	getImport(id) {
+		const row = this.db.prepare("SELECT * FROM imported_tracks WHERE id = ?").get(id);
+		return row ? this.importFrom(row) : void 0;
+	}
+	/** Imported tracks the filter lets through, in the order they were stored. */
+	findImports(filter = {}) {
+		const clauses = [];
+		const params = [];
+		if (filter.contexts) {
+			if (filter.contexts.length === 0) return [];
+			clauses.push(`context IN (${filter.contexts.map(() => "?").join(", ")})`);
+			params.push(...filter.contexts);
+		}
+		if (filter.window) {
+			clauses.push("first_time IS NOT NULL", filter.window.inclusiveEnd ? "first_time <= ?" : "first_time < ?", "last_time >= ?");
+			params.push(filter.window.to, filter.window.from);
+		}
+		if (filter.bbox) {
+			clauses.push("south <= ?", "north >= ?");
+			params.push(filter.bbox.ne[0], filter.bbox.sw[0]);
+		}
+		const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+		let rows = this.db.prepare(`SELECT * FROM imported_tracks ${where} ORDER BY rowid`).all(...params);
+		const box = filter.bbox;
+		if (box) rows = rows.filter((row) => longitudesOverlap([row.west, row.east], [box.sw[1], box.ne[1]]));
+		return rows.map((row) => this.importFrom(row));
+	}
+	importFrom(row) {
+		const points = this.selectImportedPoints.all(row.id);
+		const segments = [];
+		let current;
+		let currentIndex;
+		for (const { segment, timestamp, lat, lon } of points) {
+			if (segment !== currentIndex) {
+				current = [];
+				segments.push(current);
+				currentIndex = segment;
+			}
+			current.push(timestamp === null ? { position: [lat, lon] } : {
+				position: [lat, lon],
+				timestamp
+			});
+		}
+		return {
+			id: row.id,
+			...row.context === null ? {} : { context: row.context },
+			...row.name === null ? {} : { name: row.name },
+			metadata: JSON.parse(row.metadata),
+			segments
+		};
+	}
 	/** Worker startup snapshot; queries and name lookups must not open a second database. */
 	storedNames() {
 		return this.db.prepare("SELECT context, name, timestamp FROM names").all();
@@ -11682,6 +11995,24 @@ function mutate(operation, target) {
 		default: return false;
 	}
 }
+/** Writes whose caller waits for their own commit: imports and the recycle bin. */
+var ACKNOWLEDGED = /* @__PURE__ */ new Set([
+	"storeImport",
+	"binRecorded",
+	"binImport",
+	"restoreFromBin",
+	"purgeFromBin"
+]);
+function acknowledge(operation, target) {
+	switch (operation.method) {
+		case "storeImport": return target.storeImport(...operation.args);
+		case "binRecorded": return target.binRecorded(...operation.args);
+		case "binImport": return target.binImport(...operation.args);
+		case "restoreFromBin": return target.restoreFromBin(...operation.args);
+		case "purgeFromBin": return target.purgeFromBin(...operation.args);
+		default: throw new Error("Unknown track operation");
+	}
+}
 var isWrite = (operation) => [
 	"newPosition",
 	"recordName",
@@ -11709,6 +12040,33 @@ if (store) {
 		try {
 			for (let i = 0; i < operations.length;) {
 				const operation = operations[i];
+				if (ACKNOWLEDGED.has(operation.method)) {
+					i++;
+					if (writeFailure) {
+						results.push({
+							id: operation.id,
+							error: writeFailure
+						});
+						continue;
+					}
+					try {
+						let value;
+						target.transaction(() => {
+							value = acknowledge(operation, target);
+						});
+						results.push({
+							id: operation.id,
+							value
+						});
+					} catch (error) {
+						if (error instanceof TransactionStateError) throw error;
+						results.push({
+							id: operation.id,
+							error: errorText(error)
+						});
+					}
+					continue;
+				}
 				if (isWrite(operation)) {
 					const first = i;
 					while (i < operations.length && isWrite(operations[i])) i++;
@@ -11769,6 +12127,18 @@ if (store) {
 							case "getFilteredTimedTracks":
 								value = await target.getFilteredTimedTracks(operation.args[0], operation.args[1], debug, operation.args[3]);
 								break;
+							case "getImport":
+								value = target.getImport(...operation.args);
+								break;
+							case "findImports":
+								value = target.findImports(...operation.args);
+								break;
+							case "binEntries":
+								value = target.binEntries();
+								break;
+							case "deletedSpans":
+								value = target.deletedSpans();
+								break;
 							default: throw new Error("Unknown track operation");
 						}
 						results.push({