311 lines
8.8 KiB
TypeScript
311 lines
8.8 KiB
TypeScript
import Database from 'better-sqlite3';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { PEAKS } from './peaks-seed';
|
|
import { assignMinzoom, scorePeak } from './peak-score';
|
|
|
|
const DATA_DIR = process.env.STREBA_DATA_DIR ?? 'data';
|
|
fs.mkdirSync(DATA_DIR, { recursive: true });
|
|
|
|
export const db = new Database(path.join(DATA_DIR, 'streba.db'));
|
|
db.pragma('journal_mode = WAL');
|
|
db.pragma('foreign_keys = ON');
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
username TEXT NOT NULL UNIQUE COLLATE NOCASE,
|
|
password_hash TEXT NOT NULL,
|
|
created_at TEXT NOT NULL DEFAULT (datetime('now'))
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS sessions (
|
|
id TEXT PRIMARY KEY,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
expires_at INTEGER NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS activities (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
name TEXT NOT NULL,
|
|
type TEXT NOT NULL DEFAULT 'outdoor',
|
|
date TEXT,
|
|
distance_m REAL NOT NULL,
|
|
duration_s REAL,
|
|
moving_s REAL,
|
|
elev_gain_m REAL NOT NULL DEFAULT 0,
|
|
elev_loss_m REAL NOT NULL DEFAULT 0,
|
|
elev_min_m REAL,
|
|
elev_max_m REAL,
|
|
points TEXT NOT NULL,
|
|
bounds TEXT NOT NULL,
|
|
created_at TEXT NOT NULL DEFAULT (datetime('now'))
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_activities_user ON activities(user_id);
|
|
|
|
CREATE TABLE IF NOT EXISTS peaks (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
osm_id TEXT NOT NULL UNIQUE,
|
|
name TEXT NOT NULL,
|
|
elevation_m REAL,
|
|
lat REAL NOT NULL,
|
|
lon REAL NOT NULL,
|
|
country TEXT,
|
|
region TEXT,
|
|
wikipedia TEXT,
|
|
wikidata TEXT,
|
|
score REAL NOT NULL DEFAULT 0,
|
|
minzoom INTEGER NOT NULL DEFAULT 14
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_peaks_lat_zoom ON peaks(minzoom, lat, lon);
|
|
|
|
CREATE TABLE IF NOT EXISTS ascents (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
peak_id INTEGER NOT NULL REFERENCES peaks(id) ON DELETE CASCADE,
|
|
climbed_at TEXT,
|
|
activity_id INTEGER REFERENCES activities(id) ON DELETE SET NULL,
|
|
note TEXT,
|
|
UNIQUE (user_id, peak_id)
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_ascents_user ON ascents(user_id);
|
|
`);
|
|
|
|
// Seed the catalog with the curated list while no OSM import has run.
|
|
// Seed rows use osm_id "seed:<name>"; scripts/import-peaks.js upgrades them
|
|
// to real OSM nodes (preserving ascents) and fills in the rest of the Alps.
|
|
const peakCount = (db.prepare('SELECT count(*) n FROM peaks').get() as { n: number }).n;
|
|
if (peakCount === 0) {
|
|
const seeded = PEAKS.map((p) => ({
|
|
...p,
|
|
lat: p.lat,
|
|
lon: p.lon,
|
|
wikipedia: 'seed',
|
|
score: 0,
|
|
minzoom: 14
|
|
}));
|
|
for (const p of seeded) p.score = scorePeak(p);
|
|
assignMinzoom(seeded);
|
|
const insert = db.prepare(`
|
|
INSERT INTO peaks (osm_id, name, elevation_m, lat, lon, country, region, score, minzoom)
|
|
VALUES (@osm_id, @name, @elevation_m, @lat, @lon, @country, @region, @score, @minzoom)
|
|
`);
|
|
db.transaction(() => {
|
|
for (const p of seeded) {
|
|
insert.run({
|
|
osm_id: `seed:${p.name}`,
|
|
name: p.name,
|
|
elevation_m: p.elevation_m,
|
|
lat: p.lat,
|
|
lon: p.lon,
|
|
country: p.country,
|
|
region: p.region,
|
|
score: p.score,
|
|
minzoom: p.minzoom
|
|
});
|
|
}
|
|
})();
|
|
}
|
|
|
|
export interface ActivityRow {
|
|
id: number;
|
|
user_id: number;
|
|
name: string;
|
|
type: string;
|
|
date: string | null;
|
|
distance_m: number;
|
|
duration_s: number | null;
|
|
moving_s: number | null;
|
|
elev_gain_m: number;
|
|
elev_loss_m: number;
|
|
elev_min_m: number | null;
|
|
elev_max_m: number | null;
|
|
points: string;
|
|
bounds: string;
|
|
created_at: string;
|
|
}
|
|
|
|
export interface PeakRow {
|
|
id: number;
|
|
osm_id: string;
|
|
name: string;
|
|
elevation_m: number | null;
|
|
lat: number;
|
|
lon: number;
|
|
country: string | null;
|
|
region: string | null;
|
|
wikipedia: string | null;
|
|
wikidata: string | null;
|
|
score: number;
|
|
minzoom: number;
|
|
}
|
|
|
|
export interface AscentRow {
|
|
id: number;
|
|
user_id: number;
|
|
peak_id: number;
|
|
climbed_at: string | null;
|
|
activity_id: number | null;
|
|
note: string | null;
|
|
}
|
|
|
|
export function listActivities(userId: number): Omit<ActivityRow, 'points'>[] {
|
|
return db
|
|
.prepare(
|
|
`SELECT id, user_id, name, type, date, distance_m, duration_s, moving_s,
|
|
elev_gain_m, elev_loss_m, elev_min_m, elev_max_m, bounds, created_at
|
|
FROM activities WHERE user_id = ? ORDER BY date DESC, id DESC`
|
|
)
|
|
.all(userId) as Omit<ActivityRow, 'points'>[];
|
|
}
|
|
|
|
export function getActivity(id: number): (ActivityRow & { username: string }) | undefined {
|
|
return db
|
|
.prepare(
|
|
`SELECT a.*, u.username FROM activities a JOIN users u ON u.id = a.user_id WHERE a.id = ?`
|
|
)
|
|
.get(id) as (ActivityRow & { username: string }) | undefined;
|
|
}
|
|
|
|
/** All users' activities, newest first, with uploader attribution. */
|
|
export function listAllActivities(): (Omit<ActivityRow, 'points'> & { username: string })[] {
|
|
return db
|
|
.prepare(
|
|
`SELECT a.id, a.user_id, a.name, a.type, a.date, a.distance_m, a.duration_s, a.moving_s,
|
|
a.elev_gain_m, a.elev_loss_m, a.elev_min_m, a.elev_max_m, a.bounds, a.created_at,
|
|
u.username
|
|
FROM activities a JOIN users u ON u.id = a.user_id
|
|
ORDER BY a.date DESC, a.id DESC`
|
|
)
|
|
.all() as (Omit<ActivityRow, 'points'> & { username: string })[];
|
|
}
|
|
|
|
export function communityTotals(): {
|
|
users: number;
|
|
activities: number;
|
|
distance_m: number;
|
|
elev_gain_m: number;
|
|
} {
|
|
return db
|
|
.prepare(
|
|
`SELECT (SELECT count(*) FROM users) users,
|
|
count(*) activities,
|
|
coalesce(sum(distance_m), 0) distance_m,
|
|
coalesce(sum(elev_gain_m), 0) elev_gain_m
|
|
FROM activities`
|
|
)
|
|
.get() as { users: number; activities: number; distance_m: number; elev_gain_m: number };
|
|
}
|
|
|
|
export function deleteActivity(id: number, userId: number): void {
|
|
db.prepare('DELETE FROM activities WHERE id = ? AND user_id = ?').run(id, userId);
|
|
}
|
|
|
|
/** Notable peaks in a bounding box for a zoom level, with the user's climbed state. */
|
|
export function peaksInView(
|
|
userId: number,
|
|
bbox: { minLat: number; minLon: number; maxLat: number; maxLon: number },
|
|
zoom: number,
|
|
limit = 300
|
|
): (PeakRow & { climbed_at: string | null; ascent_activity_id: number | null })[] {
|
|
return db
|
|
.prepare(
|
|
`SELECT p.*, a.climbed_at, a.activity_id ascent_activity_id
|
|
FROM peaks p
|
|
LEFT JOIN ascents a ON a.peak_id = p.id AND a.user_id = @userId
|
|
WHERE p.minzoom <= @zoom
|
|
AND p.lat BETWEEN @minLat AND @maxLat
|
|
AND p.lon BETWEEN @minLon AND @maxLon
|
|
ORDER BY p.score DESC
|
|
LIMIT @limit`
|
|
)
|
|
.all({ userId, zoom: Math.floor(zoom), ...bbox, limit }) as (PeakRow & {
|
|
climbed_at: string | null;
|
|
ascent_activity_id: number | null;
|
|
})[];
|
|
}
|
|
|
|
/** Peaks near a track's bounding box, for summit detection on upload. */
|
|
export function peaksNearBounds(
|
|
bounds: [[number, number], [number, number]],
|
|
marginDeg = 0.01
|
|
): PeakRow[] {
|
|
return db
|
|
.prepare(
|
|
`SELECT * FROM peaks
|
|
WHERE lat BETWEEN ? AND ? AND lon BETWEEN ? AND ?`
|
|
)
|
|
.all(
|
|
bounds[0][0] - marginDeg,
|
|
bounds[1][0] + marginDeg,
|
|
bounds[0][1] - marginDeg,
|
|
bounds[1][1] + marginDeg
|
|
) as PeakRow[];
|
|
}
|
|
|
|
export function listAscents(
|
|
userId: number
|
|
): (AscentRow & { name: string; elevation_m: number | null; lat: number; lon: number })[] {
|
|
return db
|
|
.prepare(
|
|
`SELECT a.*, p.name, p.elevation_m, p.lat, p.lon
|
|
FROM ascents a JOIN peaks p ON p.id = a.peak_id
|
|
WHERE a.user_id = ?
|
|
ORDER BY p.elevation_m DESC`
|
|
)
|
|
.all(userId) as (AscentRow & {
|
|
name: string;
|
|
elevation_m: number | null;
|
|
lat: number;
|
|
lon: number;
|
|
})[];
|
|
}
|
|
|
|
export function countAscents(userId: number): number {
|
|
return (db.prepare('SELECT count(*) n FROM ascents WHERE user_id = ?').get(userId) as { n: number }).n;
|
|
}
|
|
|
|
/** Toggle an ascent; returns the new climbed_at (or null if now unclimbed). */
|
|
export function toggleAscent(userId: number, peakId: number): string | null {
|
|
const existing = db
|
|
.prepare('SELECT id FROM ascents WHERE user_id = ? AND peak_id = ?')
|
|
.get(userId, peakId) as { id: number } | undefined;
|
|
if (existing) {
|
|
db.prepare('DELETE FROM ascents WHERE id = ?').run(existing.id);
|
|
return null;
|
|
}
|
|
const date = new Date().toISOString().slice(0, 10);
|
|
db.prepare('INSERT INTO ascents (user_id, peak_id, climbed_at) VALUES (?, ?, ?)').run(
|
|
userId,
|
|
peakId,
|
|
date
|
|
);
|
|
return date;
|
|
}
|
|
|
|
export function recordAscent(
|
|
userId: number,
|
|
peakId: number,
|
|
activityId: number,
|
|
date: string | null
|
|
): boolean {
|
|
const result = db
|
|
.prepare(
|
|
`INSERT INTO ascents (user_id, peak_id, climbed_at, activity_id)
|
|
VALUES (?, ?, ?, ?)
|
|
ON CONFLICT (user_id, peak_id) DO NOTHING`
|
|
)
|
|
.run(userId, peakId, date ?? new Date().toISOString().slice(0, 10), activityId);
|
|
return result.changes > 0;
|
|
}
|
|
|
|
export function baggedPeaks(activityId: number, userId: number): (PeakRow & { climbed_at: string | null })[] {
|
|
return db
|
|
.prepare(
|
|
`SELECT p.*, a.climbed_at FROM ascents a JOIN peaks p ON p.id = a.peak_id
|
|
WHERE a.activity_id = ? AND a.user_id = ?`
|
|
)
|
|
.all(activityId, userId) as (PeakRow & { climbed_at: string | null })[];
|
|
}
|