campus-stats 0.4.0

package/dist/client.js

@@ -0,0 +1,273 @@
+/**
+ * App-facing client: install `campus` and use this from a web API,
+ * serverless function, or Node backend. Browser bundles can import query
+ * helpers against an in-memory cache loaded via `fromBundle` / `fromCache`.
+ */
+import { emptyCache, loadCache, mergeSyncResult, saveCache, cachePath, } from "./cache.js";
+import { dataBundleUrl, GITLAB_PROJECT_ID } from "./data-bundle.js";
+import { syncFantasyBundle, updateCachedCompetitions, } from "./fantasy.js";
+import { listInjuries, INJURIES_AVAILABLE, INJURIES_STATUS_MESSAGE } from "./injuries.js";
+import { DEFAULT_FANTASY_RULES, scoreFantasyPoints, } from "./scoring.js";
+function includesCI(haystack, needle) {
+    return haystack.toLowerCase().includes(needle.toLowerCase());
+}
+export class CampusClient {
+    cache;
+    persistPath;
+    constructor(cache, persistPath) {
+        this.cache = cache;
+        this.persistPath = persistPath;
+    }
+    /** Open local JSON cache (default `.campus/cache.json`). */
+    static async open(filePath = cachePath()) {
+        return new CampusClient(await loadCache(filePath), filePath);
+    }
+    /** Use an in-memory cache (e.g. after fetch in an API route). */
+    static fromCache(cache) {
+        return new CampusClient(cache);
+    }
+    /** Download the cron-published bundle and optionally merge with local cache. */
+    static async fromBundle(options = {}) {
+        const url = options.url ?? dataBundleUrl(GITLAB_PROJECT_ID);
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`Failed to load data bundle (${res.status}) from ${url}. ` +
+                "Publish via GitLab CI schedule (docs/cron.md) or call syncFantasy() once.");
+        }
+        const remote = (await res.json());
+        const incoming = {
+            ...emptyCache(),
+            competitions: remote.competitions ?? [],
+            seasons: remote.seasons ?? [],
+            teams: remote.teams ?? [],
+            matches: remote.matches ?? [],
+            identities: remote.identities ?? [],
+            players: remote.players ?? [],
+            playerMatchStats: remote.playerMatchStats ?? [],
+            lineups: remote.lineups ?? [],
+            injuries: remote.injuries ?? [],
+        };
+        const base = options.mergeWith ?? emptyCache();
+        const merged = mergeSyncResult(base, {
+            competitions: incoming.competitions,
+            seasons: incoming.seasons,
+            teams: incoming.teams,
+            matches: incoming.matches,
+            players: incoming.players,
+            playerMatchStats: incoming.playerMatchStats,
+            lineups: incoming.lineups,
+            injuries: incoming.injuries,
+        });
+        merged.identities =
+            base.identities.length > 0 ? base.identities : incoming.identities;
+        const client = new CampusClient(merged, options.persistPath);
+        if (options.persistPath)
+            await client.save();
+        return client;
+    }
+    /** Snapshot of normalized data (safe to serialize to the browser). */
+    get data() {
+        return this.cache;
+    }
+    async save(filePath = this.persistPath ?? cachePath()) {
+        await saveCache(this.cache, filePath);
+    }
+    /** Sync every women's StatsBomb competition (clubs + national teams). */
+    async syncFantasy(options = {}) {
+        const result = await syncFantasyBundle(options);
+        this.cache = mergeSyncResult(this.cache, result);
+        if (this.persistPath)
+            await this.save();
+        return this.cache;
+    }
+    /** Re-sync competitions already present in the cache. */
+    async update(options = {}) {
+        const result = await updateCachedCompetitions(this.cache, options);
+        this.cache = mergeSyncResult(this.cache, result);
+        if (this.persistPath)
+            await this.save();
+        return this.cache;
+    }
+    /** Pull the published cron bundle into this client. */
+    async pull(url) {
+        const next = await CampusClient.fromBundle({
+            url,
+            mergeWith: this.cache,
+            persistPath: this.persistPath,
+        });
+        this.cache = next.data;
+        return this.cache;
+    }
+    competitions(filter) {
+        return this.cache.competitions.filter((c) => {
+            if (filter?.name && !includesCI(c.name, filter.name))
+                return false;
+            if (filter?.international != null &&
+                Boolean(c.international) !== filter.international) {
+                return false;
+            }
+            return true;
+        });
+    }
+    seasons(filter) {
+        const competitionIds = filter?.competition
+            ? new Set(this.competitions({ name: filter.competition }).map((c) => c.id))
+            : null;
+        return this.cache.seasons.filter((s) => competitionIds ? competitionIds.has(s.competitionId) : true);
+    }
+    teams(filter) {
+        let teamIds = null;
+        if (filter?.competition) {
+            const comps = this.competitions({ name: filter.competition });
+            const ids = new Set(comps.map((c) => c.id));
+            teamIds = new Set();
+            for (const m of this.cache.matches) {
+                if (!ids.has(m.competitionId))
+                    continue;
+                teamIds.add(m.homeTeamId);
+                teamIds.add(m.awayTeamId);
+            }
+        }
+        return this.cache.teams.filter((t) => {
+            if (teamIds && !teamIds.has(t.id))
+                return false;
+            if (filter?.kind && t.kind !== filter.kind)
+                return false;
+            if (filter?.name && !includesCI(t.name, filter.name))
+                return false;
+            return true;
+        });
+    }
+    matches(filter) {
+        const comps = filter?.competition
+            ? this.competitions({ name: filter.competition })
+            : this.cache.competitions;
+        const competitionIds = new Set(comps.map((c) => c.id));
+        let seasonIds = null;
+        if (filter?.season) {
+            seasonIds = new Set(this.cache.seasons
+                .filter((s) => competitionIds.has(s.competitionId) &&
+                s.name.toLowerCase() === filter.season.toLowerCase())
+                .map((s) => s.id));
+        }
+        const teamById = new Map(this.cache.teams.map((t) => [t.id, t]));
+        return this.cache.matches.filter((m) => {
+            if (!competitionIds.has(m.competitionId))
+                return false;
+            if (seasonIds && !seasonIds.has(m.seasonId))
+                return false;
+            if (filter?.team) {
+                const home = teamById.get(m.homeTeamId)?.name ?? "";
+                const away = teamById.get(m.awayTeamId)?.name ?? "";
+                if (!includesCI(home, filter.team) && !includesCI(away, filter.team)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    players(filter) {
+        let playerIds = null;
+        if (filter?.team) {
+            const teams = this.teams({ name: filter.team });
+            const teamIds = new Set(teams.map((t) => t.id));
+            playerIds = new Set(this.cache.playerMatchStats
+                .filter((s) => teamIds.has(s.teamId))
+                .map((s) => s.playerId));
+        }
+        return this.cache.players.filter((p) => {
+            if (filter?.name && !includesCI(p.name, filter.name))
+                return false;
+            if (playerIds && !playerIds.has(p.id))
+                return false;
+            return true;
+        });
+    }
+    playerStats(filter) {
+        const matchIds = new Set(this.matches({ competition: filter?.competition }).map((m) => m.id));
+        const playerById = new Map(this.cache.players.map((p) => [p.id, p]));
+        const teamById = new Map(this.cache.teams.map((t) => [t.id, t]));
+        return this.cache.playerMatchStats.filter((s) => {
+            if (!matchIds.has(s.matchId))
+                return false;
+            if (filter?.matchId && s.matchId !== filter.matchId)
+                return false;
+            if (filter?.player) {
+                const name = playerById.get(s.playerId)?.name ?? "";
+                if (!includesCI(name, filter.player))
+                    return false;
+            }
+            if (filter?.team) {
+                const name = teamById.get(s.teamId)?.name ?? "";
+                if (!includesCI(name, filter.team))
+                    return false;
+            }
+            return true;
+        });
+    }
+    lineups(filter) {
+        const teamById = new Map(this.cache.teams.map((t) => [t.id, t]));
+        return this.cache.lineups.filter((l) => {
+            if (filter?.matchId && l.matchId !== filter.matchId)
+                return false;
+            if (filter?.team) {
+                const name = teamById.get(l.teamId)?.name ?? "";
+                if (!includesCI(name, filter.team))
+                    return false;
+            }
+            return true;
+        });
+    }
+    /** Season squad = distinct players who appeared in lineups for a team. */
+    squad(filter) {
+        const matchIds = new Set(this.matches({
+            competition: filter.competition,
+            season: filter.season,
+            team: filter.team,
+        }).map((m) => m.id));
+        const team = this.teams({
+            competition: filter.competition,
+            name: filter.team,
+        })[0];
+        if (!team)
+            return [];
+        const playerById = new Map(this.cache.players.map((p) => [p.id, p]));
+        const counts = new Map();
+        for (const l of this.cache.lineups) {
+            if (l.teamId !== team.id || !matchIds.has(l.matchId))
+                continue;
+            counts.set(l.playerId, (counts.get(l.playerId) ?? 0) + 1);
+        }
+        return [...counts.entries()]
+            .map(([playerId, appearances]) => ({
+            playerId,
+            playerName: playerById.get(playerId)?.name ?? playerId,
+            teamId: team.id,
+            teamName: team.name,
+            appearances,
+        }))
+            .sort((a, b) => a.playerName.localeCompare(b.playerName));
+    }
+    fantasyPoints(filter) {
+        const comps = filter?.competition
+            ? this.competitions({ name: filter.competition })
+            : [];
+        const competitionId = comps[0]?.id;
+        const players = filter?.player ? this.players({ name: filter.player }) : [];
+        const teams = filter?.team ? this.teams({ name: filter.team }) : [];
+        return scoreFantasyPoints(this.cache, {
+            competitionId,
+            matchId: filter?.matchId,
+            playerId: players[0]?.id,
+            teamId: teams[0]?.id,
+            rules: filter?.rules ?? DEFAULT_FANTASY_RULES,
+        });
+    }
+    injuries() {
+        return {
+            available: INJURIES_AVAILABLE,
+            message: INJURIES_STATUS_MESSAGE,
+            records: listInjuries(this.cache),
+        };
+    }
+}

package/dist/data-bundle.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Published women's fantasy data bundle (refreshed by GitLab CI cron).
+ * Generic Package Registry paths under project 86296665.
+ */
+export declare const GITLAB_PROJECT_ID = "86296665";
+export declare const DATA_BUNDLE_PACKAGE = "campus-data";
+export declare const DATA_BUNDLE_VERSION = "latest";
+export declare const DATA_BUNDLE_FILE = "cache.json";
+/** Absolute URL of the periodically refreshed cache snapshot. */
+export declare function dataBundleUrl(projectId?: string, version?: string): string;
+export declare function dataBundleMetaUrl(projectId?: string, version?: string): string;

package/dist/data-bundle.js

@@ -0,0 +1,17 @@
+/**
+ * Published women's fantasy data bundle (refreshed by GitLab CI cron).
+ * Generic Package Registry paths under project 86296665.
+ */
+export const GITLAB_PROJECT_ID = "86296665";
+export const DATA_BUNDLE_PACKAGE = "campus-data";
+export const DATA_BUNDLE_VERSION = "latest";
+export const DATA_BUNDLE_FILE = "cache.json";
+/** Absolute URL of the periodically refreshed cache snapshot. */
+export function dataBundleUrl(projectId = GITLAB_PROJECT_ID, version = DATA_BUNDLE_VERSION) {
+    return (`https://gitlab.com/api/v4/projects/${projectId}/packages/generic/` +
+        `${DATA_BUNDLE_PACKAGE}/${version}/${DATA_BUNDLE_FILE}`);
+}
+export function dataBundleMetaUrl(projectId = GITLAB_PROJECT_ID, version = DATA_BUNDLE_VERSION) {
+    return (`https://gitlab.com/api/v4/projects/${projectId}/packages/generic/` +
+        `${DATA_BUNDLE_PACKAGE}/${version}/meta.json`);
+}

package/dist/db/migrate.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_DB_PATH = ".campus/campus.sqlite";
+/** Import JSON cache into SQLite (upsert). No-op if JSON cache missing. */
+export declare function migrateJsonCacheToSqlite(dbPath?: string, jsonPath?: string): Promise<{
+    migrated: boolean;
+    path: string;
+}>;

package/dist/db/migrate.js

@@ -0,0 +1,22 @@
+import { access } from "node:fs/promises";
+import { cachePath, loadCache } from "../cache.js";
+import { SqliteStore } from "./sqlite-store.js";
+export const DEFAULT_DB_PATH = ".campus/campus.sqlite";
+/** Import JSON cache into SQLite (upsert). No-op if JSON cache missing. */
+export async function migrateJsonCacheToSqlite(dbPath = DEFAULT_DB_PATH, jsonPath = cachePath()) {
+    try {
+        await access(jsonPath);
+    }
+    catch {
+        return { migrated: false, path: dbPath };
+    }
+    const cache = await loadCache(jsonPath);
+    const store = new SqliteStore(dbPath);
+    try {
+        store.upsertCache(cache);
+    }
+    finally {
+        store.close();
+    }
+    return { migrated: true, path: dbPath };
+}

package/dist/db/sqlite-store.d.ts

@@ -0,0 +1,12 @@
+import type { CampusCache } from "../types.js";
+export declare const SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS competitions (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  country TEXT,\n  gender TEXT NOT NULL,\n  sources_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS seasons (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  competition_id TEXT NOT NULL,\n  sources_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS teams (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  country TEXT,\n  sources_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS matches (\n  id TEXT PRIMARY KEY,\n  competition_id TEXT NOT NULL,\n  season_id TEXT NOT NULL,\n  date TEXT,\n  home_team_id TEXT NOT NULL,\n  away_team_id TEXT NOT NULL,\n  home_score INTEGER,\n  away_score INTEGER,\n  sources_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS identities (\n  id TEXT PRIMARY KEY,\n  kind TEXT NOT NULL,\n  name TEXT NOT NULL,\n  aliases_json TEXT NOT NULL,\n  sources_json TEXT NOT NULL,\n  confidence TEXT NOT NULL,\n  status TEXT NOT NULL,\n  competition_hint TEXT\n);\nCREATE TABLE IF NOT EXISTS players (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  nickname TEXT,\n  country TEXT,\n  sources_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS player_match_stats (\n  id TEXT PRIMARY KEY,\n  match_id TEXT NOT NULL,\n  player_id TEXT NOT NULL,\n  team_id TEXT NOT NULL,\n  minutes INTEGER,\n  goals INTEGER NOT NULL,\n  assists INTEGER NOT NULL,\n  yellow_cards INTEGER NOT NULL,\n  red_cards INTEGER NOT NULL,\n  sources_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS lineups (\n  id TEXT PRIMARY KEY,\n  match_id TEXT NOT NULL,\n  team_id TEXT NOT NULL,\n  player_id TEXT NOT NULL,\n  started INTEGER NOT NULL,\n  jersey_number INTEGER,\n  sources_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS injuries (\n  id TEXT PRIMARY KEY,\n  player_id TEXT NOT NULL,\n  team_id TEXT,\n  status TEXT NOT NULL,\n  description TEXT,\n  from_date TEXT,\n  to_date TEXT,\n  sources_json TEXT NOT NULL\n);\n";
+export declare class SqliteStore {
+    private readonly db;
+    constructor(dbPath: string);
+    close(): void;
+    replaceAll(cache: CampusCache): void;
+    /** Upsert entities from a CampusCache slice (merge semantics). */
+    upsertCache(cache: CampusCache): void;
+    loadCache(): CampusCache;
+    private insertCache;
+}

package/dist/db/sqlite-store.js

@@ -0,0 +1,344 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS competitions (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  country TEXT,
+  gender TEXT NOT NULL,
+  sources_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS seasons (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  competition_id TEXT NOT NULL,
+  sources_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS teams (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  country TEXT,
+  sources_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS matches (
+  id TEXT PRIMARY KEY,
+  competition_id TEXT NOT NULL,
+  season_id TEXT NOT NULL,
+  date TEXT,
+  home_team_id TEXT NOT NULL,
+  away_team_id TEXT NOT NULL,
+  home_score INTEGER,
+  away_score INTEGER,
+  sources_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS identities (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  name TEXT NOT NULL,
+  aliases_json TEXT NOT NULL,
+  sources_json TEXT NOT NULL,
+  confidence TEXT NOT NULL,
+  status TEXT NOT NULL,
+  competition_hint TEXT
+);
+CREATE TABLE IF NOT EXISTS players (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  nickname TEXT,
+  country TEXT,
+  sources_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS player_match_stats (
+  id TEXT PRIMARY KEY,
+  match_id TEXT NOT NULL,
+  player_id TEXT NOT NULL,
+  team_id TEXT NOT NULL,
+  minutes INTEGER,
+  goals INTEGER NOT NULL,
+  assists INTEGER NOT NULL,
+  yellow_cards INTEGER NOT NULL,
+  red_cards INTEGER NOT NULL,
+  sources_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS lineups (
+  id TEXT PRIMARY KEY,
+  match_id TEXT NOT NULL,
+  team_id TEXT NOT NULL,
+  player_id TEXT NOT NULL,
+  started INTEGER NOT NULL,
+  jersey_number INTEGER,
+  sources_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS injuries (
+  id TEXT PRIMARY KEY,
+  player_id TEXT NOT NULL,
+  team_id TEXT,
+  status TEXT NOT NULL,
+  description TEXT,
+  from_date TEXT,
+  to_date TEXT,
+  sources_json TEXT NOT NULL
+);
+`;
+function j(value) {
+    return JSON.stringify(value);
+}
+function parseJson(raw) {
+    return JSON.parse(raw);
+}
+export class SqliteStore {
+    db;
+    constructor(dbPath) {
+        // Lazy-load so --help and JSON-only flows do not touch experimental node:sqlite.
+        const { DatabaseSync } = require("node:sqlite");
+        this.db = new DatabaseSync(dbPath);
+        this.db.exec(SCHEMA_SQL);
+    }
+    close() {
+        this.db.close();
+    }
+    replaceAll(cache) {
+        this.db.exec("BEGIN");
+        try {
+            for (const table of [
+                "competitions",
+                "seasons",
+                "teams",
+                "matches",
+                "identities",
+                "players",
+                "player_match_stats",
+                "lineups",
+                "injuries",
+            ]) {
+                this.db.prepare(`DELETE FROM ${table}`).run();
+            }
+            this.insertCache(cache);
+            this.db.exec("COMMIT");
+        }
+        catch (err) {
+            this.db.exec("ROLLBACK");
+            throw err;
+        }
+    }
+    /** Upsert entities from a CampusCache slice (merge semantics). */
+    upsertCache(cache) {
+        this.db.exec("BEGIN");
+        try {
+            this.insertCache(cache);
+            this.db.exec("COMMIT");
+        }
+        catch (err) {
+            this.db.exec("ROLLBACK");
+            throw err;
+        }
+    }
+    loadCache() {
+        const competitions = this.db
+            .prepare("SELECT * FROM competitions")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            name: String(row.name),
+            country: row.country == null ? undefined : String(row.country),
+            gender: "female",
+            sources: parseJson(String(row.sources_json)),
+        }));
+        const seasons = this.db
+            .prepare("SELECT * FROM seasons")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            name: String(row.name),
+            competitionId: String(row.competition_id),
+            sources: parseJson(String(row.sources_json)),
+        }));
+        const teams = this.db
+            .prepare("SELECT * FROM teams")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            name: String(row.name),
+            country: row.country == null ? undefined : String(row.country),
+            sources: parseJson(String(row.sources_json)),
+        }));
+        const matches = this.db
+            .prepare("SELECT * FROM matches")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            competitionId: String(row.competition_id),
+            seasonId: String(row.season_id),
+            date: row.date == null ? undefined : String(row.date),
+            homeTeamId: String(row.home_team_id),
+            awayTeamId: String(row.away_team_id),
+            homeScore: row.home_score == null ? null : Number(row.home_score),
+            awayScore: row.away_score == null ? null : Number(row.away_score),
+            sources: parseJson(String(row.sources_json)),
+        }));
+        const identities = this.db
+            .prepare("SELECT * FROM identities")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            kind: String(row.kind),
+            name: String(row.name),
+            aliases: parseJson(String(row.aliases_json)),
+            sources: parseJson(String(row.sources_json)),
+            confidence: String(row.confidence),
+            status: String(row.status),
+            competitionHint: row.competition_hint == null
+                ? undefined
+                : String(row.competition_hint),
+        }));
+        const players = this.db
+            .prepare("SELECT * FROM players")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            name: String(row.name),
+            nickname: row.nickname == null ? undefined : String(row.nickname),
+            country: row.country == null ? undefined : String(row.country),
+            sources: parseJson(String(row.sources_json)),
+        }));
+        const playerMatchStats = this.db
+            .prepare("SELECT * FROM player_match_stats")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            matchId: String(row.match_id),
+            playerId: String(row.player_id),
+            teamId: String(row.team_id),
+            minutes: row.minutes == null ? null : Number(row.minutes),
+            goals: Number(row.goals),
+            assists: Number(row.assists),
+            yellowCards: Number(row.yellow_cards),
+            redCards: Number(row.red_cards),
+            sources: parseJson(String(row.sources_json)),
+        }));
+        const lineups = this.db
+            .prepare("SELECT * FROM lineups")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            matchId: String(row.match_id),
+            teamId: String(row.team_id),
+            playerId: String(row.player_id),
+            started: Boolean(row.started),
+            jerseyNumber: row.jersey_number == null ? null : Number(row.jersey_number),
+            sources: parseJson(String(row.sources_json)),
+        }));
+        const injuries = this.db
+            .prepare("SELECT * FROM injuries")
+            .all()
+            .map((row) => ({
+            id: String(row.id),
+            playerId: String(row.player_id),
+            teamId: row.team_id == null ? undefined : String(row.team_id),
+            status: String(row.status),
+            description: row.description == null ? undefined : String(row.description),
+            fromDate: row.from_date == null ? undefined : String(row.from_date),
+            toDate: row.to_date == null ? undefined : String(row.to_date),
+            sources: parseJson(String(row.sources_json)),
+        }));
+        return {
+            competitions,
+            seasons,
+            teams,
+            matches,
+            identities,
+            players,
+            playerMatchStats,
+            lineups,
+            injuries,
+        };
+    }
+    insertCache(cache) {
+        const upsertCompetition = this.db.prepare(`INSERT INTO competitions (id, name, country, gender, sources_json)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name=excluded.name, country=excluded.country, gender=excluded.gender,
+         sources_json=excluded.sources_json`);
+        for (const c of cache.competitions) {
+            upsertCompetition.run(c.id, c.name, c.country ?? null, c.gender, j(c.sources));
+        }
+        const upsertSeason = this.db.prepare(`INSERT INTO seasons (id, name, competition_id, sources_json)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name=excluded.name, competition_id=excluded.competition_id,
+         sources_json=excluded.sources_json`);
+        for (const s of cache.seasons) {
+            upsertSeason.run(s.id, s.name, s.competitionId, j(s.sources));
+        }
+        const upsertTeam = this.db.prepare(`INSERT INTO teams (id, name, country, sources_json)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name=excluded.name, country=excluded.country, sources_json=excluded.sources_json`);
+        for (const t of cache.teams) {
+            upsertTeam.run(t.id, t.name, t.country ?? null, j(t.sources));
+        }
+        const upsertMatch = this.db.prepare(`INSERT INTO matches (
+         id, competition_id, season_id, date, home_team_id, away_team_id,
+         home_score, away_score, sources_json
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         competition_id=excluded.competition_id, season_id=excluded.season_id,
+         date=excluded.date, home_team_id=excluded.home_team_id,
+         away_team_id=excluded.away_team_id, home_score=excluded.home_score,
+         away_score=excluded.away_score, sources_json=excluded.sources_json`);
+        for (const m of cache.matches) {
+            upsertMatch.run(m.id, m.competitionId, m.seasonId, m.date ?? null, m.homeTeamId, m.awayTeamId, m.homeScore ?? null, m.awayScore ?? null, j(m.sources));
+        }
+        const upsertIdentity = this.db.prepare(`INSERT INTO identities (
+         id, kind, name, aliases_json, sources_json, confidence, status, competition_hint
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         kind=excluded.kind, name=excluded.name, aliases_json=excluded.aliases_json,
+         sources_json=excluded.sources_json, confidence=excluded.confidence,
+         status=excluded.status, competition_hint=excluded.competition_hint`);
+        for (const i of cache.identities) {
+            upsertIdentity.run(i.id, i.kind, i.name, j(i.aliases), j(i.sources), i.confidence, i.status, i.competitionHint ?? null);
+        }
+        const upsertPlayer = this.db.prepare(`INSERT INTO players (id, name, nickname, country, sources_json)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name=excluded.name, nickname=excluded.nickname, country=excluded.country,
+         sources_json=excluded.sources_json`);
+        for (const p of cache.players) {
+            upsertPlayer.run(p.id, p.name, p.nickname ?? null, p.country ?? null, j(p.sources));
+        }
+        const upsertStats = this.db.prepare(`INSERT INTO player_match_stats (
+         id, match_id, player_id, team_id, minutes, goals, assists,
+         yellow_cards, red_cards, sources_json
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         match_id=excluded.match_id, player_id=excluded.player_id,
+         team_id=excluded.team_id, minutes=excluded.minutes, goals=excluded.goals,
+         assists=excluded.assists, yellow_cards=excluded.yellow_cards,
+         red_cards=excluded.red_cards, sources_json=excluded.sources_json`);
+        for (const s of cache.playerMatchStats) {
+            upsertStats.run(s.id, s.matchId, s.playerId, s.teamId, s.minutes ?? null, s.goals, s.assists, s.yellowCards, s.redCards, j(s.sources));
+        }
+        const upsertLineup = this.db.prepare(`INSERT INTO lineups (
+         id, match_id, team_id, player_id, started, jersey_number, sources_json
+       ) VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         match_id=excluded.match_id, team_id=excluded.team_id,
+         player_id=excluded.player_id, started=excluded.started,
+         jersey_number=excluded.jersey_number, sources_json=excluded.sources_json`);
+        for (const l of cache.lineups) {
+            upsertLineup.run(l.id, l.matchId, l.teamId, l.playerId, l.started ? 1 : 0, l.jerseyNumber ?? null, j(l.sources));
+        }
+        const upsertInjury = this.db.prepare(`INSERT INTO injuries (
+         id, player_id, team_id, status, description, from_date, to_date, sources_json
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         player_id=excluded.player_id, team_id=excluded.team_id,
+         status=excluded.status, description=excluded.description,
+         from_date=excluded.from_date, to_date=excluded.to_date,
+         sources_json=excluded.sources_json`);
+        for (const i of cache.injuries) {
+            upsertInjury.run(i.id, i.playerId, i.teamId ?? null, i.status, i.description ?? null, i.fromDate ?? null, i.toDate ?? null, j(i.sources));
+        }
+    }
+}