127 lines
4.1 KiB
TypeScript
127 lines
4.1 KiB
TypeScript
/**
|
|
* Records which dumps a dump's note and comments link to, and finds the dumps
|
|
* related to one through those links. The dump and comment services keep the
|
|
* links up to date, and the dump page lists the related dumps.
|
|
*
|
|
* @module
|
|
*/
|
|
|
|
import type { Dump } from "../../shared/dump.ts";
|
|
import { db, transaction } from "../db/connection.ts";
|
|
import {
|
|
DUMP_SELECT_COLUMNS as SELECT_COLS,
|
|
dumpRowToApi,
|
|
isDumpRow,
|
|
} from "../model/dump.ts";
|
|
import { UUID_RE } from "../lib/slugify.ts";
|
|
|
|
/**
|
|
* Matches an http(s) URL in Markdown. It stops at the delimiters of
|
|
* `[text](url)` and `<url>`, which would otherwise end up in the URL.
|
|
*/
|
|
const URL_RE = /https?:\/\/[^\s)\]<>"']+/g;
|
|
|
|
/**
|
|
* Matches the path of a dump's page, `/dumps/{slug-or-id}`, and ignores what
|
|
* follows it, so an `/edit` or `#comment-x` link counts too. The host isn't
|
|
* checked, since the site's public URL differs between setups.
|
|
*/
|
|
const DUMP_PATH_RE = /^\/dumps\/([^/?#]+)/;
|
|
|
|
/** Returns `url` as the URL parser normalizes it, or null when it isn't one. */
|
|
function canonicalize(url: string): string | null {
|
|
try {
|
|
return new URL(url).toString();
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/** Returns the id of the dump with id or slug `idOrSlug`, or null. */
|
|
function resolveDumpPathId(idOrSlug: string): string | null {
|
|
const row = UUID_RE.test(idOrSlug)
|
|
? db.prepare(`SELECT id FROM dumps WHERE id = ?;`).get(idOrSlug)
|
|
: db.prepare(`SELECT id FROM dumps WHERE slug = ?;`).get(idOrSlug);
|
|
return (row as { id: string } | undefined)?.id ?? null;
|
|
}
|
|
|
|
/**
|
|
* Replaces the backlinks from one text, a dump's note (`dump_comment`) or one
|
|
* of its comments (`comment`), with the links its current `text` holds. A link
|
|
* counts when it is a dump's page on this site or the exact URL a dump was
|
|
* posted with. The dump and comment services call it on every save, and with
|
|
* an empty `text` when a comment is deleted.
|
|
*/
|
|
export function relinkBacklinks(
|
|
sourceType: "dump_comment" | "comment",
|
|
sourceId: string,
|
|
fromDumpId: string,
|
|
text: string,
|
|
): void {
|
|
const targetIds = new Set<string>();
|
|
const externalUrls = new Set<string>();
|
|
|
|
for (const match of text.matchAll(URL_RE)) {
|
|
const canonical = canonicalize(match[0]);
|
|
if (!canonical) continue;
|
|
let parsed: URL;
|
|
try {
|
|
parsed = new URL(canonical);
|
|
} catch {
|
|
continue;
|
|
}
|
|
const pathMatch = DUMP_PATH_RE.exec(parsed.pathname);
|
|
if (pathMatch) {
|
|
const resolved = resolveDumpPathId(decodeURIComponent(pathMatch[1]));
|
|
if (resolved) targetIds.add(resolved);
|
|
} else {
|
|
externalUrls.add(canonical);
|
|
}
|
|
}
|
|
|
|
if (externalUrls.size > 0) {
|
|
const placeholders = [...externalUrls].map(() => "?").join(", ");
|
|
const rows = db.prepare(
|
|
`SELECT id FROM dumps WHERE url IN (${placeholders});`,
|
|
).all(...externalUrls) as { id: string }[];
|
|
for (const row of rows) targetIds.add(row.id);
|
|
}
|
|
|
|
targetIds.delete(fromDumpId);
|
|
|
|
transaction(() => {
|
|
db.prepare(
|
|
`DELETE FROM dump_backlinks WHERE source_type = ? AND source_id = ?;`,
|
|
).run(sourceType, sourceId);
|
|
const createdAt = new Date().toISOString();
|
|
const insert = db.prepare(
|
|
`INSERT INTO dump_backlinks (source_type, source_id, from_dump_id, to_dump_id, created_at)
|
|
VALUES (?, ?, ?, ?, ?);`,
|
|
);
|
|
for (const toDumpId of targetIds) {
|
|
insert.run(sourceType, sourceId, fromDumpId, toDumpId, createdAt);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Returns the dumps linked to or from `dumpId`, newest first and at most 20,
|
|
* without the private ones the requesting user can't see. It doesn't check
|
|
* `dumpId` itself: `GET /api/dumps/:dumpId/related` does that first.
|
|
*/
|
|
export function getRelatedDumps(
|
|
dumpId: string,
|
|
requestingUserId?: string,
|
|
): Dump[] {
|
|
const rows = db.prepare(
|
|
`SELECT ${SELECT_COLS} FROM dumps WHERE id IN (
|
|
SELECT to_dump_id FROM dump_backlinks WHERE from_dump_id = ?
|
|
UNION
|
|
SELECT from_dump_id FROM dump_backlinks WHERE to_dump_id = ?
|
|
) AND (is_private = 0 OR user_id = ?)
|
|
ORDER BY created_at DESC LIMIT 20;`,
|
|
).all(dumpId, dumpId, requestingUserId ?? "");
|
|
|
|
return rows.filter(isDumpRow).map(dumpRowToApi);
|
|
}
|