289 lines
9.8 KiB
JavaScript
289 lines
9.8 KiB
JavaScript
/* ============================================================================
|
|
* db.js — libsql (embedded SQLite) database setup and query helpers
|
|
*
|
|
* The DB file lives at $DB_PATH (mounted volume in Docker so data persists
|
|
* across container rebuilds). libsql is an open-source SQLite fork by Turso
|
|
* with WAL-by-default for concurrent reads.
|
|
*
|
|
* Schema (three small tables):
|
|
* users — one row per fingerprint; tracks last app version seen
|
|
* playlists — one row per fingerprint; full playlist JSON blob
|
|
* video_history — one row per (fingerprint, video_id); recent 200 entries
|
|
* ========================================================================== */
|
|
|
|
import { createClient } from '@libsql/client';
|
|
import { join } from 'node:path';
|
|
|
|
const DB_PATH = process.env.DB_PATH || join(process.cwd(), 'data', 'ytplayer.db');
|
|
|
|
export const db = createClient({
|
|
url: 'file:' + DB_PATH,
|
|
});
|
|
|
|
// ---- Schema ----------------------------------------------------------------
|
|
|
|
export async function initDb() {
|
|
await db.executeMultiple(`
|
|
PRAGMA journal_mode = WAL;
|
|
PRAGMA synchronous = NORMAL;
|
|
PRAGMA foreign_keys = ON;
|
|
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
fingerprint TEXT PRIMARY KEY,
|
|
last_version TEXT,
|
|
last_seen INTEGER NOT NULL DEFAULT (unixepoch())
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS playlists (
|
|
fingerprint TEXT PRIMARY KEY,
|
|
data TEXT NOT NULL DEFAULT '[]',
|
|
updated_at INTEGER NOT NULL DEFAULT (unixepoch())
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS video_history (
|
|
fingerprint TEXT NOT NULL,
|
|
video_id TEXT NOT NULL,
|
|
title TEXT,
|
|
channel TEXT,
|
|
thumbnail TEXT,
|
|
duration REAL DEFAULT 0,
|
|
accessed_at INTEGER NOT NULL DEFAULT (unixepoch()),
|
|
PRIMARY KEY (fingerprint, video_id)
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_vh_fp_time
|
|
ON video_history (fingerprint, accessed_at DESC);
|
|
|
|
CREATE TABLE IF NOT EXISTS profiles (
|
|
name TEXT PRIMARY KEY,
|
|
data TEXT NOT NULL DEFAULT '{}',
|
|
created_at INTEGER NOT NULL DEFAULT (unixepoch()),
|
|
updated_at INTEGER NOT NULL DEFAULT (unixepoch())
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS shared_playlists (
|
|
code TEXT PRIMARY KEY,
|
|
data TEXT NOT NULL DEFAULT '{}',
|
|
created_at INTEGER NOT NULL DEFAULT (unixepoch())
|
|
);
|
|
|
|
-- Playlists sent from one profile to another. Holds only a pointer to the
|
|
-- shared_playlists row, never a copy of the videos, so a delivery costs a
|
|
-- few bytes and the recipient decides whether to keep it.
|
|
CREATE TABLE IF NOT EXISTS playlist_inbox (
|
|
id TEXT PRIMARY KEY,
|
|
to_name TEXT NOT NULL,
|
|
from_name TEXT,
|
|
code TEXT NOT NULL,
|
|
title TEXT NOT NULL,
|
|
created_at INTEGER NOT NULL DEFAULT (unixepoch())
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_inbox_to
|
|
ON playlist_inbox (to_name, created_at DESC);
|
|
`);
|
|
}
|
|
|
|
// ---- Profiles (named cross-device sync; the name acts as the passkey) ------
|
|
|
|
// Insert a new profile. Returns false when the name is already taken.
|
|
export async function createProfile(name, dataJson) {
|
|
try {
|
|
await db.execute({
|
|
sql: `INSERT INTO profiles (name, data, created_at, updated_at)
|
|
VALUES (?, ?, unixepoch(), unixepoch())`,
|
|
args: [name, dataJson],
|
|
});
|
|
return true;
|
|
} catch (err) {
|
|
const msg = String(err && err.message || err);
|
|
if (msg.includes('UNIQUE') || msg.includes('PRIMARY KEY')) return false;
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
export async function getProfile(name) {
|
|
const r = await db.execute({
|
|
sql: 'SELECT data, updated_at FROM profiles WHERE name = ?',
|
|
args: [name],
|
|
});
|
|
const row = r.rows[0];
|
|
if (!row) return null;
|
|
return { data: row.data, updatedAt: Number(row.updated_at) };
|
|
}
|
|
|
|
// Update an EXISTING profile's data blob. Returns false when it doesn't exist
|
|
// (saving must never implicitly create a profile — creation is a deliberate,
|
|
// uniqueness-checked act).
|
|
export async function saveProfile(name, dataJson) {
|
|
const r = await db.execute({
|
|
sql: 'UPDATE profiles SET data = ?, updated_at = unixepoch() WHERE name = ?',
|
|
args: [dataJson, name],
|
|
});
|
|
return (r.rowsAffected || 0) > 0;
|
|
}
|
|
|
|
// ---- Shared Playlists ------------------------------------------------------
|
|
|
|
// Insert a new shared playlist. Returns false when the code is already taken.
|
|
export async function createSharedPlaylist(code, dataJson) {
|
|
try {
|
|
await db.execute({
|
|
sql: `INSERT INTO shared_playlists (code, data, created_at)
|
|
VALUES (?, ?, unixepoch())`,
|
|
args: [code, dataJson],
|
|
});
|
|
return true;
|
|
} catch (err) {
|
|
const msg = String(err && err.message || err);
|
|
if (msg.includes('UNIQUE') || msg.includes('PRIMARY KEY')) return false;
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
export async function getSharedPlaylist(code) {
|
|
const r = await db.execute({
|
|
sql: 'SELECT data, created_at FROM shared_playlists WHERE code = ?',
|
|
args: [code],
|
|
});
|
|
const row = r.rows[0];
|
|
if (!row) return null;
|
|
return { data: row.data, createdAt: Number(row.created_at) };
|
|
}
|
|
|
|
// ---- Playlist inbox (profile-to-profile sends) ------------------------------
|
|
|
|
// Queue a shared playlist for a recipient profile. Caller must have verified
|
|
// the recipient exists; `code` must already be a row in shared_playlists.
|
|
export async function queueInboxPlaylist({ id, toName, fromName, code, title }) {
|
|
await db.execute({
|
|
sql: `INSERT INTO playlist_inbox (id, to_name, from_name, code, title, created_at)
|
|
VALUES (?, ?, ?, ?, ?, unixepoch())`,
|
|
args: [id, toName, fromName || null, code, title],
|
|
});
|
|
}
|
|
|
|
// Pending deliveries for a profile, oldest first so they are offered in the
|
|
// order they were sent. Capped so a flooded inbox can't blow up the response.
|
|
export async function listInbox(toName, limit = 20) {
|
|
const r = await db.execute({
|
|
sql: `SELECT id, from_name, code, title, created_at
|
|
FROM playlist_inbox
|
|
WHERE to_name = ?
|
|
ORDER BY created_at ASC
|
|
LIMIT ?`,
|
|
args: [toName, limit],
|
|
});
|
|
return r.rows.map((row) => ({
|
|
id: row.id,
|
|
from: row.from_name || null,
|
|
code: row.code,
|
|
title: row.title,
|
|
createdAt: Number(row.created_at),
|
|
}));
|
|
}
|
|
|
|
// Remove one delivery once the recipient has kept or dismissed it. Scoped by
|
|
// to_name so knowing an id alone cannot clear someone else's inbox.
|
|
export async function deleteInboxItem(toName, id) {
|
|
const r = await db.execute({
|
|
sql: 'DELETE FROM playlist_inbox WHERE to_name = ? AND id = ?',
|
|
args: [toName, id],
|
|
});
|
|
return (r.rowsAffected || 0) > 0;
|
|
}
|
|
|
|
// How many deliveries this recipient already has waiting — used to refuse a
|
|
// send that would flood an inbox.
|
|
export async function countInbox(toName) {
|
|
const r = await db.execute({
|
|
sql: 'SELECT COUNT(*) AS n FROM playlist_inbox WHERE to_name = ?',
|
|
args: [toName],
|
|
});
|
|
return Number(r.rows[0] ? r.rows[0].n : 0);
|
|
}
|
|
|
|
// ---- Helpers ---------------------------------------------------------------
|
|
|
|
// Upsert the users row and optionally update playlists.
|
|
export async function upsertUser({ fingerprint, appVersion, playlists }) {
|
|
await db.execute({
|
|
sql: `INSERT INTO users (fingerprint, last_version, last_seen)
|
|
VALUES (?, ?, unixepoch())
|
|
ON CONFLICT(fingerprint) DO UPDATE SET
|
|
last_version = excluded.last_version,
|
|
last_seen = excluded.last_seen`,
|
|
args: [fingerprint, appVersion || null],
|
|
});
|
|
|
|
if (Array.isArray(playlists)) {
|
|
await db.execute({
|
|
sql: `INSERT INTO playlists (fingerprint, data, updated_at)
|
|
VALUES (?, ?, unixepoch())
|
|
ON CONFLICT(fingerprint) DO UPDATE SET
|
|
data = excluded.data,
|
|
updated_at = excluded.updated_at`,
|
|
args: [fingerprint, JSON.stringify(playlists)],
|
|
});
|
|
}
|
|
}
|
|
|
|
// Record a video access (insert or bump accessed_at).
|
|
export async function recordVideoAccess(fingerprint, video) {
|
|
await db.execute({
|
|
sql: `INSERT INTO video_history
|
|
(fingerprint, video_id, title, channel, thumbnail, duration, accessed_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, unixepoch())
|
|
ON CONFLICT(fingerprint, video_id) DO UPDATE SET
|
|
title = excluded.title,
|
|
channel = excluded.channel,
|
|
thumbnail = excluded.thumbnail,
|
|
duration = excluded.duration,
|
|
accessed_at = excluded.accessed_at`,
|
|
args: [
|
|
fingerprint,
|
|
video.id,
|
|
video.title || null,
|
|
video.channel || null,
|
|
video.thumbnail || null,
|
|
video.duration || 0,
|
|
],
|
|
});
|
|
|
|
// Keep only the 200 most recent entries per user to avoid unbounded growth
|
|
await db.execute({
|
|
sql: `DELETE FROM video_history
|
|
WHERE fingerprint = ?
|
|
AND video_id NOT IN (
|
|
SELECT video_id FROM video_history
|
|
WHERE fingerprint = ?
|
|
ORDER BY accessed_at DESC
|
|
LIMIT 200
|
|
)`,
|
|
args: [fingerprint, fingerprint],
|
|
});
|
|
}
|
|
|
|
// Fetch stored data for a fingerprint.
|
|
export async function getUserData(fingerprint) {
|
|
const [userRow, plRow, histRows] = await Promise.all([
|
|
db.execute({ sql: 'SELECT last_version FROM users WHERE fingerprint = ?', args: [fingerprint] }),
|
|
db.execute({ sql: 'SELECT data FROM playlists WHERE fingerprint = ?', args: [fingerprint] }),
|
|
db.execute({
|
|
sql: `SELECT video_id AS id, title, channel, thumbnail, duration, accessed_at
|
|
FROM video_history WHERE fingerprint = ?
|
|
ORDER BY accessed_at DESC LIMIT 50`,
|
|
args: [fingerprint],
|
|
}),
|
|
]);
|
|
|
|
const lastVersion = userRow.rows[0]?.last_version || null;
|
|
const playlists = plRow.rows[0]?.data ? JSON.parse(plRow.rows[0].data) : [];
|
|
const history = histRows.rows.map((r) => ({
|
|
id: r.id, title: r.title, channel: r.channel,
|
|
thumbnail: r.thumbnail, duration: r.duration,
|
|
}));
|
|
|
|
return { lastVersion, playlists, history };
|
|
}
|