@geekity/cms 0.30.0 → 0.31.0

package/dist/content/store.js

@@ -1,18 +1,6 @@
-import { databaseFile, openDatabase } from '../cache.js';
-import { featuredPosts, PINNED_FRONT_MATTER_KEY } from './pinned.js';
-import { searchExpression, searchText, SNIPPET_CLOSE, SNIPPET_OPEN } from './search.js';
-import { tagKey, uniqueTags } from './tags.js';
-import { VISIBILITIES, VISIBILITY_FRONT_MATTER_KEY } from './visibility.js';
-import { repliesKey } from '../web/feed-source.js';
-import { feedGuid, postObjectId } from '../web/guids.js';
-import { absoluteUrl } from '../web/negotiate.js';
-import { NO_REDIRECTS } from '../web/redirects.js';
-import { linksInto, ownSiteLinks, siteLinkKey, spelling } from '../webmention/links.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 live 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
@@ -55,1042 +43,4 @@ 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 > ?)';
-const VISIBILITY_SQL = `COALESCE(json_extract(extra, '$.${VISIBILITY_FRONT_MATTER_KEY}'), 'public')`;
-const SERVED_CLAUSE = `(draft = 0 AND trashed = 0 AND ${DUE_CLAUSE} AND ${VISIBILITY_SQL} IN (${VISIBILITIES.map((visibility) => `'${visibility}'`).join(', ')}))`;
-const LISTED_CLAUSE = `(${SERVED_CLAUSE} AND ${VISIBILITY_SQL} = 'public')`;
-/**
- * A document whose front matter carries a `pinned` key that is not `false`.
- * Which moment it was pinned at, and whether it is readable at all, is
- * `content/pinned.ts`'s to decide; this only keeps the rest of an archive from
- * being hydrated to find out.
- */
-const PINNED_CLAUSE = `COALESCE(json_extract(extra, '$.${PINNED_FRONT_MATTER_KEY}'), 0) NOT IN (0, '')`;
-/**
- * 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 ${LISTED_CLAUSE}
-`;
-/**
- * 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 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 (
-        path, type, slug, permalink, title, date, date_sort, updated, draft, trashed,
-        description, author, in_reply_to, activitypub, extra, body, html, hash,
-        replies_key, reply_post_key, keys_base
-      ) VALUES (
-        :path, :type, :slug, :permalink, :title, :date, :date_sort, :updated, :draft, :trashed,
-        :description, :author, :in_reply_to, :activitypub, :extra, :body, :html, :hash,
-        :replies_key, :reply_post_key, :keys_base
-      )
-      ON CONFLICT (path) DO UPDATE SET
-        type = excluded.type,
-        slug = excluded.slug,
-        permalink = excluded.permalink,
-        title = excluded.title,
-        date = excluded.date,
-        date_sort = excluded.date_sort,
-        updated = excluded.updated,
-        draft = excluded.draft,
-        trashed = excluded.trashed,
-        description = excluded.description,
-        author = excluded.author,
-        in_reply_to = excluded.in_reply_to,
-        activitypub = excluded.activitypub,
-        extra = excluded.extra,
-        body = excluded.body,
-        html = excluded.html,
-        hash = excluded.hash,
-        replies_key = excluded.replies_key,
-        reply_post_key = excluded.reply_post_key,
-        keys_base = excluded.keys_base
-    `),
-        rowsKeyedElsewhere: db.prepare('SELECT * FROM documents WHERE keys_base IS NOT ?'),
-        writeKeys: db.prepare(`
-      UPDATE documents
-      SET replies_key = :replies_key, reply_post_key = :reply_post_key, keys_base = :keys_base
-      WHERE path = :path
-    `),
-        byRepliesKey: db.prepare(`
-      SELECT * FROM documents
-      WHERE (replies_key = ?1 OR reply_post_key = ?1) AND ${SERVED_CLAUSE}
-      ORDER BY replies_key = ?1 DESC, date_sort DESC, path DESC
-    `),
-        deleteTags: db.prepare('DELETE FROM document_tags WHERE path = ?'),
-        insertTag: db.prepare('INSERT INTO document_tags (path, tag, key, 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 = ? AND trashed = 0'),
-        remove: db.prepare('DELETE FROM documents WHERE path = ?'),
-        byPath: db.prepare('SELECT * FROM documents WHERE path = ?'),
-        byPermalink: db.prepare('SELECT * FROM documents WHERE permalink = ? ORDER BY trashed, path DESC LIMIT 1'),
-        deleteLinks: db.prepare('DELETE FROM document_links WHERE path = ?'),
-        insertLink: db.prepare('INSERT INTO document_links (path, target, query) VALUES (?, ?, ?)'),
-        servedAt: db.prepare(`SELECT 1 FROM documents WHERE permalink = ? AND ${SERVED_CLAUSE} LIMIT 1`),
-        deleteRedirects: db.prepare('DELETE FROM document_redirects WHERE path = ?'),
-        insertRedirect: db.prepare('INSERT INTO document_redirects (path, url, position) VALUES (?, ?, ?)'),
-        redirectsFor: db.prepare('SELECT url FROM document_redirects WHERE path = ? ORDER BY position'),
-        byFormerPermalink: db.prepare(`
-      SELECT documents.* FROM documents
-      JOIN document_redirects ON document_redirects.path = documents.path
-      WHERE document_redirects.url = ?
-        AND ${SERVED_CLAUSE}
-      ORDER BY documents.updated DESC, documents.path DESC
-      LIMIT 1
-    `),
-        byStoredObjectId: db.prepare(`SELECT * FROM documents WHERE json_extract(activitypub, '$.id') = ? ORDER BY trashed LIMIT 1`),
-        bySlug: db.prepare(`SELECT * FROM documents WHERE slug = ? ORDER BY date_sort DESC, path DESC LIMIT 1`),
-        tagsFor: db.prepare('SELECT tag, key FROM document_tags WHERE path = ? ORDER BY position'),
-        keysFor: db.prepare('SELECT key FROM document_tags WHERE path = ?'),
-        spellings: db.prepare(tagSpellingsSql('')),
-        spellingsOfKeys: db.prepare(tagSpellingsSql('WHERE spelled.key IN (SELECT value FROM json_each(:keys))')),
-        spellingExcluding: db.prepare(tagSpellingsSql('WHERE spelled.key = :key AND spelled.path <> :excluding')),
-        dataVersion: db.prepare('PRAGMA data_version'),
-        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 ${LISTED_CLAUSE}), 0) AS posts,
-        COALESCE(SUM(type = 'page' AND ${LISTED_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
-    `),
-        tagCounts: db.prepare(`
-      SELECT document_tags.key AS key, MIN(document_tags.tag) AS tag, COUNT(*) AS count
-      FROM document_tags
-      JOIN documents ON documents.path = document_tags.path
-      WHERE ${LISTED_CLAUSE}
-      GROUP BY document_tags.key
-    `),
-        categoryCounts: db.prepare(`
-      SELECT document_categories.category AS category, COUNT(*) AS count
-      FROM document_categories
-      JOIN documents ON documents.path = document_categories.path
-      WHERE ${LISTED_CLAUSE}
-      GROUP BY document_categories.category
-      ORDER BY count DESC, category ASC
-    `),
-        tagUsage: db.prepare(termUsageSql(TERM_TABLES.tag)),
-        categoryUsage: db.prepare(termUsageSql(TERM_TABLES.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;
-    /**
-     * Work out again everything worked out against another base, or none: the
-     * `/replies/` keys and the links to the site's own pages.
-     */
-    function refreshAgainstBase(baseUrl) {
-        db.exec('BEGIN');
-        try {
-            for (const row of statements.rowsKeyedElsewhere.all(baseUrl)) {
-                const document = toDocument(row, [], []);
-                statements.writeKeys.run({ path: document.path, ...repliesKeysOf(document, baseUrl) });
-                writeLinks(document, baseUrl);
-            }
-            db.exec('COMMIT');
-        }
-        catch (error) {
-            db.exec('ROLLBACK');
-            throw error;
-        }
-    }
-    if (options.baseUrl !== undefined)
-        refreshAgainstBase(options.baseUrl);
-    let cachedSpellings;
-    const staleKeys = new Set();
-    const MOST_KEYS_REFRESHED = 500;
-    function siteSpellings() {
-        const now = nowKey();
-        const dataVersion = statements.dataVersion.get()?.['data_version'];
-        const current = cachedSpellings === undefined || outOfDate(cachedSpellings, dataVersion, now)
-            ? undefined
-            : cachedSpellings.byKey;
-        if (current !== undefined && staleKeys.size === 0)
-            return current;
-        const refreshStaleOnly = current !== undefined && staleKeys.size <= MOST_KEYS_REFRESHED;
-        const byKey = refreshStaleOnly ? current : new Map();
-        const rows = refreshStaleOnly
-            ? refreshStaleSpellings(byKey, now)
-            : statements.spellings.all(now);
-        for (const row of rows)
-            byKey.set(String(row['key']), String(row['tag']));
-        staleKeys.clear();
-        const nextScheduledAt = text(statements.nextDue.get(now)['due']);
-        cachedSpellings = { byKey, dataVersion, workedOutAt: now, nextScheduledAt };
-        return byKey;
-    }
-    function refreshStaleSpellings(byKey, now) {
-        for (const key of staleKeys)
-            byKey.delete(key);
-        return statements.spellingsOfKeys.all({ keys: JSON.stringify([...staleKeys]) }, now);
-    }
-    function markTagsStaleBeforeWrite(contentPath) {
-        for (const row of statements.keysFor.all(contentPath))
-            staleKeys.add(String(row['key']));
-    }
-    function tagsOf(contentPath) {
-        const spellings = siteSpellings();
-        return statements.tagsFor
-            .all(contentPath)
-            .map((row) => spellings.get(String(row['key'])) ?? 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 hydrateOne(row);
-    }
-    function hydrateOne(row) {
-        const contentPath = String(row['path']);
-        const redirectFrom = statements.redirectsFor
-            .all(contentPath)
-            .map((redirect) => String(redirect['url']));
-        return {
-            ...toDocument(row, tagsOf(contentPath), categoriesOf(contentPath)),
-            ...(redirectFrom.length === 0 ? {} : { redirectFrom }),
-        };
-    }
-    function hydrateAll(rows) {
-        return rows.map(hydrateOne);
-    }
-    function writeLinks(document, baseUrl) {
-        statements.deleteLinks.run(document.path);
-        if (baseUrl === undefined)
-            return;
-        const pageUrl = absoluteUrl(document.permalink, baseUrl);
-        for (const { path, query } of ownSiteLinks(document.html, pageUrl, baseUrl)) {
-            statements.insertLink.run(document.path, path, query);
-        }
-    }
-    /**
-     * The paths a link to `document` may name: its permalink, and each of its
-     * former ones that the site still answers with it rather than with a live
-     * document holding it now or another document claiming it.
-     */
-    function linkKeysOf(document) {
-        const former = (document.redirectFrom ?? []).filter((url) => statements.byPermalink.get(url) === undefined &&
-            text(statements.byFormerPermalink.get(url, nowKey())?.['path']) === document.path);
-        return [...new Set([document.permalink, ...former].map(siteLinkKey))];
-    }
-    function writeOne(document) {
-        const contentPath = document.path;
-        markTagsStaleBeforeWrite(contentPath);
-        for (const tag of document.tags)
-            staleKeys.add(tagKey(tag));
-        try {
-            statements.insert.run({ ...toRow(document), ...repliesKeysOf(document, options.baseUrl) });
-        }
-        catch (error) {
-            throw translateWriteError(error, document, statements.pathForPermalink);
-        }
-        statements.deleteTags.run(contentPath);
-        uniqueTags(document.tags).forEach((tag, position) => {
-            statements.insertTag.run(contentPath, tag, tagKey(tag), position);
-        });
-        statements.deleteCategories.run(contentPath);
-        document.categories.forEach((category, position) => {
-            statements.insertCategory.run(contentPath, category, position);
-        });
-        statements.deleteRedirects.run(contentPath);
-        (document.redirectFrom ?? []).forEach((url, position) => {
-            statements.insertRedirect.run(contentPath, url, position);
-        });
-        writeLinks(document, options.baseUrl);
-        // 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(terms, term, options) {
-        const where = [LISTED_CLAUSE, termFilter(terms)];
-        const params = [nowKey(), terms.match(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(terms, term, options) {
-        const { table, matchColumn } = terms;
-        const where = [LISTED_CLAUSE, `${table}.${matchColumn} = ?`];
-        const params = [nowKey(), terms.match(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 ${LISTED_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 ')}`;
-        const rows = db
-            .prepare(`SELECT * FROM documents ${clause} ORDER BY date_sort DESC, path DESC ${limitClause(options)}`)
-            .all(...params, ...limitParams(options));
-        return hydrateAll(rows);
-    }
-    return {
-        file,
-        now() {
-            return clock();
-        },
-        upsert(document) {
-            writeOne(document);
-        },
-        upsertAll(documents) {
-            db.exec('BEGIN');
-            try {
-                for (const document of documents)
-                    writeOne(document);
-                db.exec('COMMIT');
-            }
-            catch (error) {
-                db.exec('ROLLBACK');
-                throw error;
-            }
-        },
-        remove(contentPath) {
-            markTagsStaleBeforeWrite(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() {
-            cachedSpellings = undefined;
-            staleKeys.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 document_redirects');
-                db.exec('DELETE FROM document_links');
-                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));
-        },
-        getByFormerPermalink(permalink) {
-            return hydrate(statements.byFormerPermalink.get(permalink, nowKey()));
-        },
-        getBySlug(slug) {
-            return hydrate(statements.bySlug.get(slug));
-        },
-        listPosts(options = {}) {
-            return select(["type = 'post'", LISTED_CLAUSE], [nowKey()], options);
-        },
-        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 = {}) {
-            return selectByTerm(TERM_TABLES.tag, tag, options);
-        },
-        listByCategory(category, options = {}) {
-            return selectByTerm(TERM_TABLES.category, category, options);
-        },
-        listByAuthor(names, options = {}) {
-            if (names.length === 0)
-                return [];
-            return select(["type = 'post'", LISTED_CLAUSE, authorClause(names)], [nowKey(), ...names], options);
-        },
-        listPinnedByAuthor(names) {
-            if (names.length === 0)
-                return [];
-            return featuredPosts(select(["type = 'post'", LISTED_CLAUSE, authorClause(names), PINNED_CLAUSE], [nowKey(), ...names], {}));
-        },
-        listAll(options = {}) {
-            const where = [];
-            const params = [];
-            if (options.type !== undefined) {
-                where.push('type = ?');
-                params.push(options.type);
-            }
-            if (options.draft !== undefined) {
-                where.push('draft = ?');
-                params.push(options.draft ? 1 : 0);
-            }
-            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(termFilter(TERM_TABLES.tag));
-                params.push(TERM_TABLES.tag.match(options.tag));
-            }
-            if (options.category !== undefined) {
-                where.push(termFilter(TERM_TABLES.category));
-                params.push(TERM_TABLES.category.match(options.category));
-            }
-            return select(where, params, options);
-        },
-        listFederated(options = {}) {
-            return select([`type = 'post'`, FEDERATED_CLAUSE], [], options);
-        },
-        listRepliesTo(targets) {
-            const wanted = [...new Set(targets)];
-            if (wanted.length === 0)
-                return [];
-            return select(["type = 'post'", SERVED_CLAUSE, `in_reply_to IN (${wanted.map(() => '?').join(', ')})`], [nowKey(), ...wanted], {});
-        },
-        listReplyPosts(options = {}) {
-            return select(["type = 'post'", SERVED_CLAUSE, 'in_reply_to IS NOT NULL'], [nowKey()], options);
-        },
-        listByRepliesKey(key) {
-            return hydrateAll(statements.byRepliesKey.all(key, nowKey()));
-        },
-        listBacklinks(document, site = {}) {
-            const now = nowKey();
-            const answeredAt = linkKeysOf(document);
-            if (site.home === true)
-                answeredAt.push('/');
-            const into = linksInto(site.redirects ?? NO_REDIRECTS, answeredAt, (sitePath) => [sitePath, `${sitePath}/`].some((url) => statements.servedAt.get(url, now) !== undefined ||
-                statements.byFormerPermalink.get(url, now) !== undefined));
-            return select([
-                LISTED_CLAUSE,
-                'path <> ?',
-                `path IN (
-            SELECT path FROM document_links
-            WHERE target IN (SELECT value FROM json_each(?))
-              AND (query = '' OR target || '?' || query NOT IN (SELECT value FROM json_each(?)))
-            UNION
-            SELECT path FROM document_links
-            WHERE target IN (SELECT value FROM json_each(?))
-              AND target || '?' || query IN (SELECT value FROM json_each(?))
-          )`,
-            ], [
-                now,
-                document.path,
-                JSON.stringify(into.paths),
-                JSON.stringify(into.intercepted),
-                JSON.stringify(into.queries.map((link) => link.path)),
-                JSON.stringify(into.queries.map(spelling)),
-            ], {});
-        },
-        listPaths() {
-            return statements.paths.all().map((row) => String(row['path']));
-        },
-        counts() {
-            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 = {}) {
-            return countByTerm(TERM_TABLES.tag, tag, options);
-        },
-        countByCategory(category, options = {}) {
-            return countByTerm(TERM_TABLES.category, category, options);
-        },
-        countByAuthor(names) {
-            if (names.length === 0)
-                return 0;
-            const row = db
-                .prepare(`SELECT COUNT(*) AS count FROM documents
-           WHERE type = 'post' AND ${LISTED_CLAUSE} AND ${authorClause(names)}`)
-                .get(...[nowKey(), ...names]);
-            return Number(row['count']);
-        },
-        listTags() {
-            const spellings = siteSpellings();
-            return statements.tagCounts
-                .all(nowKey())
-                .map((row) => ({
-                tag: spellings.get(String(row['key'])) ?? String(row['tag']),
-                count: Number(row['count']),
-            }))
-                .sort((a, b) => b.count - a.count || compareByUtf16CodeUnit(a.tag, b.tag));
-        },
-        tagSpelling(tag, options = {}) {
-            if (options.excluding === undefined)
-                return siteSpellings().get(tagKey(tag));
-            const row = statements.spellingExcluding.get({ key: tagKey(tag), excluding: options.excluding }, nowKey());
-            return text(row?.['tag']);
-        },
-        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;
-            const spellings = taxonomy === 'tag' ? siteSpellings() : new Map();
-            return query
-                .all(nowKey())
-                .map((row) => ({
-                term: spellings.get(String(row['key'])) ?? String(row['term']),
-                published: Number(row['published']),
-                total: Number(row['total']),
-            }))
-                .sort((a, b) => compareByUtf16CodeUnit(a.term, b.term));
-        },
-        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']);
-        },
-        setReadOnly(readOnly) {
-            db.exec(`PRAGMA query_only = ${readOnly ? 'ON' : 'OFF'}`);
-        },
-        close() {
-            if (!open)
-                return;
-            open = false;
-            db.close();
-        },
-    };
-}
-const TERM_TABLES = {
-    tag: { table: 'document_tags', matchColumn: 'key', column: 'tag', match: tagKey },
-    category: {
-        table: 'document_categories',
-        matchColumn: 'category',
-        column: 'category',
-        match: (category) => category,
-    },
-};
-function outOfDate(cache, dataVersion, now) {
-    return (anotherConnectionWrote(cache, dataVersion) ||
-        scheduledPostCameDue(cache, now) ||
-        clockWentBack(cache, now));
-}
-function anotherConnectionWrote(cache, dataVersion) {
-    return cache.dataVersion !== dataVersion;
-}
-function scheduledPostCameDue(cache, now) {
-    return cache.nextScheduledAt !== undefined && now >= cache.nextScheduledAt;
-}
-function clockWentBack(cache, now) {
-    return now < cache.workedOutAt;
-}
-function compareByUtf16CodeUnit(a, b) {
-    if (a === b)
-        return 0;
-    return a < b ? -1 : 1;
-}
-function termFilter({ table, matchColumn }) {
-    return `path IN (SELECT path FROM ${table} WHERE ${matchColumn} = ?)`;
-}
-function tagSpellingsSql(where) {
-    return `
-    SELECT key, tag FROM (
-      SELECT key, tag, ROW_NUMBER() OVER (
-        PARTITION BY key
-        ORDER BY SUM(listed) DESC,
-          MIN(CASE WHEN listed THEN date_sort END) ASC NULLS LAST,
-          COUNT(*) DESC,
-          MIN(date_sort) ASC NULLS LAST,
-          tag ASC
-      ) AS rank
-      FROM (
-        SELECT spelled.key AS key, spelled.tag AS tag,
-          ${LISTED_CLAUSE} AS listed, spelled_in.date_sort AS date_sort
-        FROM document_tags AS spelled
-        JOIN documents AS spelled_in ON spelled_in.path = spelled.path
-        ${where}
-      )
-      GROUP BY key, tag
-    )
-    WHERE rank = 1
-  `;
-}
-function termUsageSql({ table, matchColumn, column }) {
-    return `
-    SELECT ${table}.${matchColumn} AS key, MIN(${table}.${column}) AS term,
-      COALESCE(SUM(${LISTED_CLAUSE}), 0) AS published,
-      COUNT(*) AS total
-    FROM ${table}
-    JOIN documents ON documents.path = ${table}.path
-    GROUP BY ${table}.${matchColumn}
-  `;
-}
-/**
- * `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 '';
-    return 'LIMIT ? OFFSET ?';
-}
-function limitParams(options) {
-    if (options.limit === undefined && options.offset === undefined)
-        return [];
-    return [options.limit ?? -1, options.offset ?? 0];
-}
-/**
- * The `/replies/` keys of a document (TASK-327): its feed guid's, and for a
- * reply post its object id's, which is what it is named by in the thread it
- * answers. The two differ only for a reply post with a stored `guid`. Both are
- * worked out against `baseUrl`, which is recorded beside them so a change of
- * site URL is noticed on the next open; with no base there are no keys.
- */
-function repliesKeysOf(document, baseUrl) {
-    if (baseUrl === undefined)
-        return { replies_key: null, reply_post_key: null, keys_base: null };
-    const isReplyPost = document.type === 'post' && document.inReplyTo !== undefined;
-    return {
-        replies_key: repliesKey(feedGuid(document, baseUrl)),
-        reply_post_key: isReplyPost ? repliesKey(postObjectId(document, baseUrl)) : null,
-        keys_base: baseUrl,
-    };
-}
-/** A {@link Document} as the columns of the `documents` table. */
-function toRow(document) {
-    return {
-        path: document.path,
-        type: document.type,
-        slug: document.slug,
-        permalink: document.permalink,
-        title: document.title,
-        date: document.date ?? null,
-        date_sort: dateSortKey(document.date),
-        updated: document.updated ?? null,
-        draft: document.draft ? 1 : 0,
-        trashed: isTrashedPath(document.path) ? 1 : 0,
-        description: document.description ?? null,
-        author: document.author ?? null,
-        in_reply_to: document.inReplyTo ?? null,
-        activitypub: document.activitypub === undefined ? null : JSON.stringify(document.activitypub),
-        extra: JSON.stringify(document.extra),
-        body: document.body,
-        html: document.html,
-        hash: document.hash,
-    };
-}
-/**
- * A row back into a {@link 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, categories) {
-    return {
-        type: String(row['type']),
-        path: String(row['path']),
-        slug: String(row['slug']),
-        permalink: String(row['permalink']),
-        title: String(row['title']),
-        ...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'])),
-        ...optional('inReplyTo', text(row['in_reply_to'])),
-        ...optional('activitypub', json(row['activitypub'])),
-        extra: json(row['extra']) ?? {},
-        body: String(row['body']),
-        html: String(row['html']),
-        hash: String(row['hash']),
-    };
-}
-function text(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-function json(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    return JSON.parse(value);
-}
-function optional(key, value) {
-    return value === undefined ? {} : { [key]: value };
-}
-/**
- * Turn SQLite's unique-constraint message into something a site owner can act
- * on. Everything else is rethrown untouched.
- */
-function translateWriteError(error, document, pathForPermalink) {
-    if (!isUniqueViolation(error, 'documents.permalink'))
-        return error;
-    const row = pathForPermalink.get(document.permalink);
-    return new DuplicatePermalinkError(document.permalink, document.path, text(row?.['path']));
-}
-function isUniqueViolation(error, column) {
-    if (!(error instanceof Error))
-        return false;
-    const code = error.code;
-    if (code !== 'ERR_SQLITE_ERROR')
-        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
- * that starts fresh.
- */
-const MIGRATIONS = [
-    {
-        version: 1,
-        sql: `
-      CREATE TABLE documents (
-        path         TEXT PRIMARY KEY,
-        type         TEXT NOT NULL,
-        slug         TEXT NOT NULL,
-        permalink    TEXT NOT NULL,
-        title        TEXT NOT NULL,
-        date         TEXT,
-        date_sort    TEXT,
-        updated      TEXT,
-        draft        INTEGER NOT NULL,
-        trashed      INTEGER NOT NULL,
-        description  TEXT,
-        author       TEXT,
-        activitypub  TEXT,
-        extra        TEXT NOT NULL,
-        body         TEXT NOT NULL,
-        html         TEXT NOT NULL,
-        hash         TEXT NOT NULL
-      );
-
-      CREATE UNIQUE INDEX documents_permalink ON documents (permalink);
-      CREATE INDEX documents_slug ON documents (slug);
-      CREATE INDEX documents_listing ON documents (type, draft, trashed, date_sort DESC);
-
-      CREATE TABLE document_tags (
-        path     TEXT NOT NULL REFERENCES documents (path) ON DELETE CASCADE,
-        tag      TEXT NOT NULL,
-        position INTEGER NOT NULL,
-        PRIMARY KEY (path, tag)
-      );
-
-      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;
-    `,
-    },
-    {
-        version: 5,
-        sql: `
-      -- \`in-reply-to\` is modelled now (TASK-121). A file that already had one
-      -- kept it in \`extra\`, and may hash the same as it did, so a scan would
-      -- leave the row alone and never learn the post is a reply. 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).
-      ALTER TABLE documents ADD COLUMN in_reply_to TEXT;
-      DELETE FROM documents;
-    `,
-    },
-    {
-        version: 6,
-        sql: `
-      -- The URLs a document used to live at, from its \`redirect_from\` (TASK-127),
-      -- so an old URL is one indexed lookup. A file that already carried the
-      -- key kept it in \`extra\` and hashes the same, so a scan would never
-      -- index it; emptying the index makes the next scan read every file again,
-      -- and the files are the source of truth, so nothing is lost (decision-1).
-      CREATE TABLE document_redirects (
-        path     TEXT NOT NULL REFERENCES documents (path) ON DELETE CASCADE,
-        url      TEXT NOT NULL,
-        position INTEGER NOT NULL,
-        PRIMARY KEY (path, url)
-      );
-
-      CREATE INDEX document_redirects_url ON document_redirects (url);
-      DELETE FROM documents;
-    `,
-    },
-    {
-        version: 7,
-        sql: `
-      -- A trashed document gives its URL up to a live one (TASK-195), so the
-      -- permalink is unique among untrashed rows only. The plain index stays
-      -- for lookups, which ask about trashed rows too.
-      DROP INDEX documents_permalink;
-      CREATE UNIQUE INDEX documents_permalink_live ON documents (permalink) WHERE trashed = 0;
-      CREATE INDEX documents_permalink ON documents (permalink);
-    `,
-    },
-    {
-        version: 8,
-        sql: `
-      -- Tags match without regard to case (TASK-308): each row carries its
-      -- key, the tag in lower case, which JavaScript works out because
-      -- SQLite's lower() folds ASCII only. A document carries a tag once
-      -- whatever its casing. The rows already here have no key, and their
-      -- files hash the same, so emptying the index is what makes the next
-      -- scan write them again; the files are the source of truth (decision-1).
-      DROP TABLE document_tags;
-      CREATE TABLE document_tags (
-        path     TEXT NOT NULL REFERENCES documents (path) ON DELETE CASCADE,
-        tag      TEXT NOT NULL,
-        key      TEXT NOT NULL,
-        position INTEGER NOT NULL,
-        PRIMARY KEY (path, key)
-      );
-      CREATE INDEX document_tags_key ON document_tags (key);
-      DELETE FROM documents;
-    `,
-    },
-    {
-        version: 9,
-        sql: `
-      -- A thread finds the reply posts answering it by their \`in-reply-to\`
-      -- (TASK-300).
-      CREATE INDEX documents_in_reply_to ON documents (in_reply_to);
-    `,
-    },
-    {
-        version: 10,
-        sql: `
-      -- What a \`/replies/\` key names (TASK-327), so resolving one is a lookup
-      -- rather than a walk of the site. The keys hang off the base URL, which
-      -- a migration does not know: the rows are filled when the store is
-      -- opened with one, as they are whenever that base changes.
-      ALTER TABLE documents ADD COLUMN replies_key TEXT;
-      ALTER TABLE documents ADD COLUMN reply_post_key TEXT;
-      ALTER TABLE documents ADD COLUMN keys_base TEXT;
-      CREATE INDEX documents_replies_key ON documents (replies_key);
-      CREATE INDEX documents_reply_post_key ON documents (reply_post_key);
-    `,
-    },
-    {
-        version: 11,
-        sql: `
-      -- The pages of the site each document links to (TASK-322), as the paths
-      -- the links name rather than the documents they lead to, which are
-      -- matched when a document's backlinks are read. A link keeps its query
-      -- (TASK-330), sorted as a redirect source's is, because the site answers
-      -- \`/?p=7\` with a redirect rather than with \`/\`. Like the \`/replies/\`
-      -- keys they are read against the base URL, so forgetting every row's
-      -- base is what makes the next open with one fill them from the stored
-      -- HTML, with no scan of the files.
-      CREATE TABLE document_links (
-        path   TEXT NOT NULL REFERENCES documents (path) ON DELETE CASCADE,
-        target TEXT NOT NULL,
-        query  TEXT NOT NULL DEFAULT '',
-        PRIMARY KEY (path, target, query)
-      );
-      CREATE INDEX document_links_target ON document_links (target);
-      UPDATE documents SET keys_base = NULL;
-    `,
-    },
-];
 //# sourceMappingURL=store.js.map