@geekity/cms 0.3.0 → 0.5.0

package/dist/content/store.js

@@ -1,10 +1,10 @@
-import { mkdirSync } from 'node:fs';
-import path from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-/** File name of the derived index inside a site's data directory. */
-export const DATABASE_FILE = 'geekity.db';
+import { databaseFile, openDatabase } from '../cache.js';
+import { searchExpression, searchText, SNIPPET_CLOSE, SNIPPET_OPEN } from './search.js';
+export { DATABASE_FILE } from '../cache.js';
 /** Directory name that marks a document as thrown away but not yet deleted. */
 export const TRASH_DIRECTORY = '_trash';
+/** The clock an index uses when it is not given one. */
+export const systemClock = () => new Date();
 /**
  * Thrown when two files claim the same permalink. Two documents at one URL is
  * a content mistake the site owner has to fix, so the index refuses it rather
@@ -47,18 +47,67 @@ export function dateSortKey(date) {
     const parsed = new Date(date);
     return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
 }
+/**
+ * The clause every public query carries: a document is public only once its
+ * date has arrived.
+ *
+ * A document with no date — or one nobody can read — has nothing to wait for
+ * and is public straight away, which is what keeps an undated page out of the
+ * scheduling rule without a second predicate. The value compared against is a
+ * {@link dateSortKey} of the clock, so the comparison is between two UTC ISO
+ * strings and lexicographic order is chronological order.
+ */
+const DUE_CLAUSE = '(date_sort IS NULL OR date_sort <= ?)';
+/** The reverse: a document whose date is still ahead of the clock. */
+const SCHEDULED_CLAUSE = '(date_sort IS NOT NULL AND date_sort > ?)';
+/**
+ * The clause that picks out a document some follower holds a copy of: one
+ * whose `activitypub` block records when it was announced.
+ *
+ * `published` rather than `id`, because after decision-13 a post's id is its
+ * permalink and is never written into the file: the announcement date is the
+ * only mark a delivery leaves, and it is the one thing that says a follower
+ * was ever told. The block is stored as JSON rather than shredded into
+ * columns, so the date is read back out of it here. An empty value is no
+ * value: the front matter is a file somebody may have typed, and
+ * `activitypub: {published: ""}` is what a half-finished hand edit looks like.
+ */
+const FEDERATED_CLAUSE = `COALESCE(json_extract(activitypub, '$.published'), '') <> ''`;
+/**
+ * The public side of a search: the full-text match joined to the documents it
+ * indexes, held to exactly what every public listing is held to.
+ *
+ * The draft, trash and due clauses are applied to the documents table rather
+ * than indexed alongside the words, so a post that is drafted, trashed or
+ * pushed into the future drops out of the results the moment the listings drop
+ * it, with no second write to keep in step.
+ */
+const SEARCH_FROM = `
+  FROM documents_fts
+  JOIN documents ON documents.path = documents_fts.path
+  WHERE documents_fts MATCH ?
+    AND documents.draft = 0 AND documents.trashed = 0
+    AND (documents.date_sort IS NULL OR documents.date_sort <= ?)
+`;
+/**
+ * How much a match in each column of the index counts, in the order the table
+ * declares them: the path is not indexed, a title match counts for most, the
+ * description and the taxonomy for half as much, and the body for least.
+ */
+const SEARCH_WEIGHTS = '0.0, 10.0, 5.0, 5.0, 1.0';
 /**
  * Open (and if needed create) the index in `dataDir`, applying every migration
  * the package ships. Applying them is idempotent, so reopening an up-to-date
  * database does nothing.
  */
 export function openContentStore(options) {
-    const file = path.join(options.dataDir, DATABASE_FILE);
-    mkdirSync(options.dataDir, { recursive: true });
-    const db = new DatabaseSync(file);
-    db.exec('PRAGMA journal_mode = WAL');
-    db.exec('PRAGMA foreign_keys = ON');
-    migrate(db);
+    const clock = options.now ?? systemClock;
+    /** The clock as the index sorts dates, so the two compare as strings. */
+    function nowKey() {
+        return clock().toISOString();
+    }
+    const file = databaseFile(options.dataDir);
+    const db = openDatabase({ dataDir: options.dataDir, ledger: LEDGER, migrations: MIGRATIONS });
     const statements = {
         insert: db.prepare(`
       INSERT INTO documents (
@@ -88,19 +137,24 @@ export function openContentStore(options) {
     `),
         deleteTags: db.prepare('DELETE FROM document_tags WHERE path = ?'),
         insertTag: db.prepare('INSERT INTO document_tags (path, tag, position) VALUES (?, ?, ?)'),
+        deleteCategories: db.prepare('DELETE FROM document_categories WHERE path = ?'),
+        insertCategory: db.prepare('INSERT INTO document_categories (path, category, position) VALUES (?, ?, ?)'),
         pathForPermalink: db.prepare('SELECT path FROM documents WHERE permalink = ?'),
         remove: db.prepare('DELETE FROM documents WHERE path = ?'),
         byPath: db.prepare('SELECT * FROM documents WHERE path = ?'),
         byPermalink: db.prepare('SELECT * FROM documents WHERE permalink = ?'),
+        byStoredObjectId: db.prepare(`SELECT * FROM documents WHERE json_extract(activitypub, '$.id') = ? LIMIT 1`),
         bySlug: db.prepare(`SELECT * FROM documents WHERE slug = ? ORDER BY date_sort DESC, path DESC LIMIT 1`),
         tagsFor: db.prepare('SELECT tag FROM document_tags WHERE path = ? ORDER BY position'),
+        categoriesFor: db.prepare('SELECT category FROM document_categories WHERE path = ? ORDER BY position'),
         paths: db.prepare('SELECT path FROM documents ORDER BY path'),
         counts: db.prepare(`
       SELECT
         COUNT(*) AS total,
-        COALESCE(SUM(type = 'post' AND draft = 0 AND trashed = 0), 0) AS posts,
-        COALESCE(SUM(type = 'page' AND draft = 0 AND trashed = 0), 0) AS pages,
+        COALESCE(SUM(type = 'post' AND draft = 0 AND trashed = 0 AND ${DUE_CLAUSE}), 0) AS posts,
+        COALESCE(SUM(type = 'page' AND draft = 0 AND trashed = 0 AND ${DUE_CLAUSE}), 0) AS pages,
         COALESCE(SUM(draft = 1 AND trashed = 0), 0) AS drafts,
+        COALESCE(SUM(draft = 0 AND trashed = 0 AND ${SCHEDULED_CLAUSE}), 0) AS scheduled,
         COALESCE(SUM(trashed = 1), 0) AS trashed
       FROM documents
     `),
@@ -109,21 +163,60 @@ export function openContentStore(options) {
       FROM document_tags
       JOIN documents ON documents.path = document_tags.path
       WHERE documents.draft = 0 AND documents.trashed = 0
+        AND (documents.date_sort IS NULL OR documents.date_sort <= ?)
       GROUP BY document_tags.tag
       ORDER BY count DESC, tag ASC
+    `),
+        categoryCounts: db.prepare(`
+      SELECT document_categories.category AS category, COUNT(*) AS count
+      FROM document_categories
+      JOIN documents ON documents.path = document_categories.path
+      WHERE documents.draft = 0 AND documents.trashed = 0
+        AND (documents.date_sort IS NULL OR documents.date_sort <= ?)
+      GROUP BY document_categories.category
+      ORDER BY count DESC, category ASC
+    `),
+        tagUsage: db.prepare(termUsageSql('document_tags', 'tag')),
+        categoryUsage: db.prepare(termUsageSql('document_categories', 'category')),
+        nextDue: db.prepare(`
+      SELECT MIN(date_sort) AS due FROM documents
+      WHERE draft = 0 AND trashed = 0 AND ${SCHEDULED_CLAUSE}
+    `),
+        deleteText: db.prepare('DELETE FROM documents_fts WHERE path = ?'),
+        insertText: db.prepare('INSERT INTO documents_fts (path, title, description, terms, body) VALUES (?, ?, ?, ?, ?)'),
+        search: db.prepare(`
+      SELECT documents.*,
+        snippet(documents_fts, -1, '${SNIPPET_OPEN}', '${SNIPPET_CLOSE}', '…', 24) AS snippet
+      ${SEARCH_FROM}
+      ORDER BY bm25(documents_fts, ${SEARCH_WEIGHTS}), documents.date_sort DESC, documents.path DESC
+      LIMIT ? OFFSET ?
+    `),
+        countSearch: db.prepare(`SELECT COUNT(*) AS count ${SEARCH_FROM}`),
+        dueSince: db.prepare(`
+      SELECT * FROM documents
+      WHERE draft = 0 AND trashed = 0
+        AND date_sort IS NOT NULL AND date_sort > ? AND date_sort <= ?
+      ORDER BY date_sort ASC, path ASC
     `),
     };
     let open = true;
     function tagsOf(contentPath) {
         return statements.tagsFor.all(contentPath).map((row) => String(row['tag']));
     }
+    function categoriesOf(contentPath) {
+        return statements.categoriesFor.all(contentPath).map((row) => String(row['category']));
+    }
     function hydrate(row) {
         if (row === undefined)
             return undefined;
-        return toDocument(row, tagsOf(String(row['path'])));
+        return hydrateOne(row);
+    }
+    function hydrateOne(row) {
+        const contentPath = String(row['path']);
+        return toDocument(row, tagsOf(contentPath), categoriesOf(contentPath));
     }
     function hydrateAll(rows) {
-        return rows.map((row) => toDocument(row, tagsOf(String(row['path']))));
+        return rows.map(hydrateOne);
     }
     function writeOne(document) {
         const contentPath = document.path;
@@ -137,6 +230,72 @@ export function openContentStore(options) {
         document.tags.forEach((tag, position) => {
             statements.insertTag.run(contentPath, tag, position);
         });
+        statements.deleteCategories.run(contentPath);
+        document.categories.forEach((category, position) => {
+            statements.insertCategory.run(contentPath, category, position);
+        });
+        // The words it is found by. Replaced rather than updated, because an FTS5
+        // table has no key to conflict on: the path is only a column in it.
+        const words = searchText(document);
+        statements.deleteText.run(contentPath);
+        statements.insertText.run(contentPath, words.title, words.description, words.terms, words.body);
+    }
+    /**
+     * One taxonomy archive: the published, untrashed documents whose term list
+     * holds `term`, newest first. Tags and categories are the same query over two
+     * tables, so neither can drift from the other.
+     */
+    function selectByTerm(table, column, term, options) {
+        const where = [
+            'draft = 0',
+            'trashed = 0',
+            DUE_CLAUSE,
+            `path IN (SELECT path FROM ${table} WHERE ${column} = ?)`,
+        ];
+        const params = [nowKey(), term];
+        if (options.type !== undefined) {
+            where.unshift('type = ?');
+            params.unshift(options.type);
+        }
+        return select(where, params, options);
+    }
+    /** {@link selectByTerm}'s total, for the pager and the archive's existence. */
+    function countByTerm(table, column, term, options) {
+        const where = [
+            'documents.draft = 0',
+            'documents.trashed = 0',
+            '(documents.date_sort IS NULL OR documents.date_sort <= ?)',
+            `${table}.${column} = ?`,
+        ];
+        const params = [nowKey(), term];
+        if (options.type !== undefined) {
+            where.push('documents.type = ?');
+            params.push(options.type);
+        }
+        const row = db
+            .prepare(`SELECT COUNT(*) AS count FROM ${table}
+         JOIN documents ON documents.path = ${table}.path
+         WHERE ${where.join(' AND ')}`)
+            .get(...params);
+        return Number(row['count']);
+    }
+    /**
+     * The nearest published post on one side of a point in the archive.
+     *
+     * `direction` is which way to look — `<` for older, `>` for newer — and
+     * `order` is the sort that puts the nearest one first, so one query serves
+     * both ends of {@link ContentStore.neighbours}.
+     */
+    function neighbour(direction, order, key, contentPath) {
+        const row = db
+            .prepare(`SELECT * FROM documents
+         WHERE type = 'post' AND draft = 0 AND trashed = 0 AND ${DUE_CLAUSE}
+           AND date_sort IS NOT NULL
+           AND (date_sort, path) ${direction} (?, ?)
+         ORDER BY date_sort ${order}, path ${order}
+         LIMIT 1`)
+            .get(...[nowKey(), key, contentPath]);
+        return hydrate(row);
     }
     function select(where, params, options) {
         const clause = where.length === 0 ? '' : `WHERE ${where.join(' AND ')}`;
@@ -147,6 +306,9 @@ export function openContentStore(options) {
     }
     return {
         file,
+        now() {
+            return clock();
+        },
         upsert(document) {
             writeOne(document);
         },
@@ -163,32 +325,88 @@ export function openContentStore(options) {
             }
         },
         remove(contentPath) {
+            // Nothing cascades into a virtual table, so the words go by hand.
+            statements.deleteText.run(contentPath);
             return statements.remove.run(contentPath).changes > 0;
         },
+        clear() {
+            db.exec('BEGIN');
+            try {
+                // All four by name. The two term tables would go with the documents
+                // through their foreign keys, but a virtual table has none to cascade
+                // through — and a clear that depended on a pragma being on for half of
+                // what it empties would be a clear that half worked.
+                db.exec('DELETE FROM documents_fts');
+                db.exec('DELETE FROM document_tags');
+                db.exec('DELETE FROM document_categories');
+                db.exec('DELETE FROM documents');
+                db.exec('COMMIT');
+            }
+            catch (error) {
+                db.exec('ROLLBACK');
+                throw error;
+            }
+        },
         getByPath(contentPath) {
             return hydrate(statements.byPath.get(contentPath));
         },
         getByPermalink(permalink) {
             return hydrate(statements.byPermalink.get(permalink));
         },
+        getByStoredObjectId(objectId) {
+            if (objectId === '')
+                return undefined;
+            return hydrate(statements.byStoredObjectId.get(objectId));
+        },
         getBySlug(slug) {
             return hydrate(statements.bySlug.get(slug));
         },
         listPosts(options = {}) {
-            return select(["type = 'post'", 'draft = 0', 'trashed = 0'], [], options);
+            return select(["type = 'post'", 'draft = 0', 'trashed = 0', DUE_CLAUSE], [nowKey()], options);
+        },
+        listPostsSince(instant) {
+            const since = dateSortKey(instant);
+            if (since === null)
+                return [];
+            return select(["type = 'post'", 'draft = 0', 'trashed = 0', DUE_CLAUSE, 'date_sort >= ?'], [nowKey(), since], {});
+        },
+        neighbours(document) {
+            // A page is nobody's neighbour, and neither is a document the archive
+            // does not order: without a date there is no place in the sequence to be
+            // either side of.
+            const key = dateSortKey(document.date);
+            if (document.type !== 'post' || key === null)
+                return {};
+            // The listings are ordered by `date_sort DESC, path DESC`, so "before"
+            // and "after" are that same pair compared as a row: two posts sharing an
+            // instant are separated by their paths exactly as the listing separates
+            // them, and the document itself is excluded by the comparison being
+            // strict.
+            const previous = neighbour('<', 'DESC', key, document.path);
+            const next = neighbour('>', 'ASC', key, document.path);
+            return {
+                ...(previous === undefined ? {} : { previous }),
+                ...(next === undefined ? {} : { next }),
+            };
+        },
+        nextDue() {
+            const row = statements.nextDue.get(nowKey());
+            return text(row['due']);
+        },
+        listDueSince(after) {
+            const rows = statements.dueSince.all(after, nowKey());
+            return hydrateAll(rows);
         },
         listByTag(tag, options = {}) {
-            const where = [
-                'draft = 0',
-                'trashed = 0',
-                'path IN (SELECT path FROM document_tags WHERE tag = ?)',
-            ];
-            const params = [tag];
-            if (options.type !== undefined) {
-                where.unshift('type = ?');
-                params.unshift(options.type);
-            }
-            return select(where, params, options);
+            return selectByTerm('document_tags', 'tag', tag, options);
+        },
+        listByCategory(category, options = {}) {
+            return selectByTerm('document_categories', 'category', category, options);
+        },
+        listByAuthor(names, options = {}) {
+            if (names.length === 0)
+                return [];
+            return select(["type = 'post'", 'draft = 0', 'trashed = 0', DUE_CLAUSE, authorClause(names)], [nowKey(), ...names], options);
         },
         listAll(options = {}) {
             const where = [];
@@ -203,45 +421,88 @@ export function openContentStore(options) {
             }
             where.push('trashed = ?');
             params.push(options.trashed === true ? 1 : 0);
+            if (options.scheduled !== undefined) {
+                where.push(options.scheduled ? SCHEDULED_CLAUSE : DUE_CLAUSE);
+                params.push(nowKey());
+            }
             if (options.tag !== undefined) {
                 where.push('path IN (SELECT path FROM document_tags WHERE tag = ?)');
                 params.push(options.tag);
             }
+            if (options.category !== undefined) {
+                where.push('path IN (SELECT path FROM document_categories WHERE category = ?)');
+                params.push(options.category);
+            }
             return select(where, params, options);
         },
+        listFederated(options = {}) {
+            return select([`type = 'post'`, FEDERATED_CLAUSE], [], options);
+        },
         listPaths() {
             return statements.paths.all().map((row) => String(row['path']));
         },
         counts() {
-            const row = statements.counts.get();
+            const now = nowKey();
+            const row = statements.counts.get(now, now, now);
             return {
                 total: Number(row['total']),
                 posts: Number(row['posts']),
                 pages: Number(row['pages']),
                 drafts: Number(row['drafts']),
+                scheduled: Number(row['scheduled']),
                 trashed: Number(row['trashed']),
             };
         },
         countByTag(tag, options = {}) {
-            const where = ['documents.draft = 0', 'documents.trashed = 0', 'document_tags.tag = ?'];
-            const params = [tag];
-            if (options.type !== undefined) {
-                where.push('documents.type = ?');
-                params.push(options.type);
-            }
+            return countByTerm('document_tags', 'tag', tag, options);
+        },
+        countByCategory(category, options = {}) {
+            return countByTerm('document_categories', 'category', category, options);
+        },
+        countByAuthor(names) {
+            if (names.length === 0)
+                return 0;
             const row = db
-                .prepare(`SELECT COUNT(*) AS count FROM document_tags
-           JOIN documents ON documents.path = document_tags.path
-           WHERE ${where.join(' AND ')}`)
-                .get(...params);
+                .prepare(`SELECT COUNT(*) AS count FROM documents
+           WHERE type = 'post' AND draft = 0 AND trashed = 0
+             AND ${DUE_CLAUSE} AND ${authorClause(names)}`)
+                .get(...[nowKey(), ...names]);
             return Number(row['count']);
         },
         listTags() {
-            return statements.tagCounts.all().map((row) => ({
+            return statements.tagCounts.all(nowKey()).map((row) => ({
                 tag: String(row['tag']),
                 count: Number(row['count']),
             }));
         },
+        listCategories() {
+            return statements.categoryCounts.all(nowKey()).map((row) => ({
+                category: String(row['category']),
+                count: Number(row['count']),
+            }));
+        },
+        listTermUsage(taxonomy) {
+            const query = taxonomy === 'tag' ? statements.tagUsage : statements.categoryUsage;
+            return query.all(nowKey()).map((row) => ({
+                term: String(row['term']),
+                published: Number(row['published']),
+                total: Number(row['total']),
+            }));
+        },
+        search(query, options = {}) {
+            const expression = searchExpression(query);
+            if (expression === undefined)
+                return [];
+            const rows = statements.search.all(expression, nowKey(), options.limit ?? -1, options.offset ?? 0);
+            return rows.map((row) => ({ document: hydrateOne(row), snippet: String(row['snippet']) }));
+        },
+        countSearch(query) {
+            const expression = searchExpression(query);
+            if (expression === undefined)
+                return 0;
+            const row = statements.countSearch.get(expression, nowKey());
+            return Number(row['count']);
+        },
         close() {
             if (!open)
                 return;
@@ -250,6 +511,38 @@ export function openContentStore(options) {
         },
     };
 }
+/**
+ * The query behind {@link ContentStore.listTermUsage} for one of the two join
+ * tables: every term, the public count and the total, in one pass.
+ *
+ * The table and column names are the module's own literals rather than
+ * anything a caller supplies, so there is nothing here to interpolate from
+ * outside; the clock is the one bound parameter.
+ */
+function termUsageSql(table, column) {
+    return `
+    SELECT ${table}.${column} AS term,
+      COALESCE(SUM(
+        documents.draft = 0 AND documents.trashed = 0
+          AND (documents.date_sort IS NULL OR documents.date_sort <= ?)
+      ), 0) AS published,
+      COUNT(*) AS total
+    FROM ${table}
+    JOIN documents ON documents.path = ${table}.path
+    GROUP BY ${table}.${column}
+    ORDER BY term ASC
+  `;
+}
+/**
+ * `author IN (?, ?, …)`, with one placeholder per name.
+ *
+ * Only the count of the names is interpolated; every name itself is a bound
+ * parameter, so a display name holding a quote is a string to match rather
+ * than anything SQLite reads as syntax.
+ */
+function authorClause(names) {
+    return `author IN (${names.map(() => '?').join(', ')})`;
+}
 function limitClause(options) {
     if (options.limit === undefined && options.offset === undefined)
         return '';
@@ -288,7 +581,7 @@ function toRow(document) {
  * Optional fields are left off entirely when the column is NULL, so a document
  * that went through the index deep-equals the one that was parsed from the file.
  */
-function toDocument(row, tags) {
+function toDocument(row, tags, categories) {
     return {
         type: String(row['type']),
         path: String(row['path']),
@@ -298,6 +591,7 @@ function toDocument(row, tags) {
         ...optional('date', text(row['date'])),
         ...optional('updated', text(row['updated'])),
         tags,
+        categories,
         draft: row['draft'] === 1,
         ...optional('description', text(row['description'])),
         ...optional('author', text(row['author'])),
@@ -337,6 +631,8 @@ function isUniqueViolation(error, column) {
         return false;
     return error.message.includes('UNIQUE constraint failed') && error.message.includes(column);
 }
+/** The table this store's applied versions are recorded in. */
+const LEDGER = 'migrations';
 /**
  * Schema versions, applied in order. Never edit a migration that has shipped;
  * append a new one, so a site that upgrades lands on the same schema as a site
@@ -380,32 +676,61 @@ const MIGRATIONS = [
       CREATE INDEX document_tags_tag ON document_tags (tag);
     `,
     },
+    {
+        version: 2,
+        sql: `
+      CREATE TABLE document_categories (
+        path     TEXT NOT NULL REFERENCES documents (path) ON DELETE CASCADE,
+        category TEXT NOT NULL,
+        position INTEGER NOT NULL,
+        PRIMARY KEY (path, category)
+      );
+
+      CREATE INDEX document_categories_category ON document_categories (category);
+
+      -- A file that already carried categories hashes the same as it did
+      -- before the key was modelled, so a sync would find every row up to date
+      -- and never learn what those files are filed under. Emptying the index
+      -- is what makes the next scan read them all again; the files are the
+      -- source of truth, so nothing is lost (decision-1).
+      DELETE FROM documents;
+    `,
+    },
+    {
+        version: 3,
+        sql: `
+      -- The renderer now puts \`tabindex="0"\` on every \`<pre>\` (TASK-86), so a
+      -- wide block of code can be scrolled from the keyboard. The HTML in this
+      -- table was rendered by the old one, and the hash covers the file rather
+      -- than what was made of it, so a scan would find every row up to date and
+      -- serve the old markup for as long as nobody edited the post. Emptying
+      -- the index is what makes the next scan render them all again; the files
+      -- are the source of truth, so nothing is lost (decision-1).
+      DELETE FROM documents;
+    `,
+    },
+    {
+        version: 4,
+        sql: `
+      -- The full-text index (TASK-22): one row per document, keyed by path,
+      -- holding the words it is found by. \`porter\` so "running" finds "run",
+      -- \`remove_diacritics\` so "cafe" finds "café".
+      CREATE VIRTUAL TABLE documents_fts USING fts5 (
+        path UNINDEXED,
+        title,
+        description,
+        terms,
+        body,
+        tokenize = 'porter unicode61 remove_diacritics 2'
+      );
+
+      -- The body is indexed as the text of its rendered HTML, which SQL cannot
+      -- work out from the row, and the hash covers the file rather than the
+      -- index, so a scan would find every row up to date and never fill the
+      -- table. Emptying the index is what makes the next scan index them all;
+      -- the files are the source of truth, so nothing is lost (decision-1).
+      DELETE FROM documents;
+    `,
+    },
 ];
-function migrate(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS migrations (
-      version    INTEGER PRIMARY KEY,
-      applied_at TEXT NOT NULL
-    )
-  `);
-    const applied = new Set(db
-        .prepare('SELECT version FROM migrations')
-        .all()
-        .map((row) => Number(row['version'])));
-    const record = db.prepare('INSERT INTO migrations (version, applied_at) VALUES (?, ?)');
-    for (const migration of MIGRATIONS) {
-        if (applied.has(migration.version))
-            continue;
-        db.exec('BEGIN');
-        try {
-            db.exec(migration.sql);
-            record.run(migration.version, new Date().toISOString());
-            db.exec('COMMIT');
-        }
-        catch (error) {
-            db.exec('ROLLBACK');
-            throw error;
-        }
-    }
-}
 //# sourceMappingURL=store.js.map