@crowi/api 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/migration/migrations/code-mask.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * Markdown code-region segmentation for the body-rewrite migrations.
+ *
+ * `WIKILINK_DETECTION_REGEX` (and the sibling `files-url` / `html-recover`
+ * probes) scan a page's *raw* body with no Markdown awareness, so `</…>`
+ * tokens written as code examples — inside a ```` ``` ```` fence or `` `…` ``
+ * inline span — get misdetected as v1 wikilinks and rewritten, corrupting the
+ * code (e.g. ```` ```tsx\n</AppShell>\n``` ```` → `[[/AppShell]]`).
+ *
+ * The renderer already solves this at the AST level — `renderer/core/
+ * wikilinks.ts` skips `node.type === 'code' || 'inlineCode'`. The migration
+ * layer cannot import the renderer pipeline (jiti/ESM), so this is a
+ * string-level parallel of that intent: split the body into ordered
+ * `code` / non-`code` segments so callers can run their rewrite **only on
+ * the non-`code` segments** and re-join in original order.
+ *
+ * Why segmentation and NOT a same-length `\x00` fill + slice restore: a fill
+ * pass keeps the body length-invariant, but the rewrite step changes the
+ * length of the *non-code* text, so a positional restore drifts. Worse, three
+ * structural failures cause silent data loss — adjacent code regions whose
+ * fills touch merge into one `/\x00+/g` match (one region is dropped), a
+ * fence-first stash with text-order restore swaps two regions, and a `\x00`
+ * already present in pasted/binary content collides with the sentinel. By
+ * returning an ordered segment list with no restore step, all three are
+ * avoided *by construction*: adjacent regions are distinct segments (no
+ * merge), order is preserved by the list (no swap), and no sentinel is ever
+ * introduced (no collision).
+ *
+ * Coverage: fenced code blocks (CommonMark §4.5, backtick **and** tilde) and
+ * inline code spans (§6.1). Indented code blocks (4-space / 1-tab, §4.4) are
+ * deliberately NOT covered: a flat "4-space line = code" rule over-suppresses
+ * (mdast treats a 4-space paragraph/list continuation line as text/html, i.e.
+ * rewritable), so an indented-code `</…>` token stays rewritable — an accepted
+ * known divergence from the renderer (see the spec's "out of scope").
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCodeSegments = splitCodeSegments;
+exports.rewriteOutsideCode = rewriteOutsideCode;
+/** A fenced-code-block opener: ≥3 backticks or ≥3 tildes with 0–3 leading spaces. */
+const FENCE_OPEN_REGEX = /^( {0,3})(`{3,}|~{3,})/;
+/**
+ * Split `body` into ordered `code` / non-`code` segments.
+ *
+ * Fenced blocks are matched line-by-line (a fence runs to its closing fence of
+ * the same char, ≥ the opening length; an unclosed fence runs to EOF). Within
+ * non-fence text, inline code spans are matched by the CommonMark §6.1 rule: an
+ * opening run of N backticks closed by the next run of *exactly* N backticks.
+ * An unmatched backtick run is left as literal non-code text.
+ *
+ * Pure: no I/O, no mutation of inputs. Concatenating the returned segments'
+ * `text` reproduces `body` byte-for-byte.
+ */
+function splitCodeSegments(body) {
+    const segments = [];
+    // Buffer of pending non-code text; flushed (after inline-span extraction)
+    // whenever a fence boundary or EOF is reached.
+    let pendingText = '';
+    const flushPendingText = () => {
+        if (pendingText.length === 0)
+            return;
+        for (const seg of splitInlineCode(pendingText))
+            segments.push(seg);
+        pendingText = '';
+    };
+    // Walk the body line by line, preserving each line's trailing newline so the
+    // re-join is byte-identical. `lineStart` indexes the current line's first
+    // char in `body`.
+    let lineStart = 0;
+    while (lineStart < body.length) {
+        let lineEnd = body.indexOf('\n', lineStart);
+        if (lineEnd === -1)
+            lineEnd = body.length;
+        else
+            lineEnd += 1; // include the newline
+        const line = body.slice(lineStart, lineEnd);
+        // No `\r?\n` strip on the opener: `FENCE_OPEN_REGEX` is `^`-anchored and
+        // carries no end-of-line pattern, so a trailing newline never affects the
+        // match (unlike the closing-fence test below, where the strip is
+        // load-bearing — see `closeRegex.test(...)`).
+        const fenceMatch = FENCE_OPEN_REGEX.exec(line);
+        if (fenceMatch) {
+            // A fenced code block opens here. Flush text accumulated before it, then
+            // consume lines up to (and including) the matching closing fence or EOF.
+            flushPendingText();
+            // `fenceChar` is exactly one of `` ` `` / `~` because group 2 of
+            // `FENCE_OPEN_REGEX` is `` (`{3,}|~{3,}) ``, so it can be inlined into the
+            // close pattern verbatim (no per-char ternary needed).
+            const fenceChar = fenceMatch[2][0];
+            const fenceLen = fenceMatch[2].length;
+            const closeRegex = new RegExp(`^ {0,3}${fenceChar}{${fenceLen},}[ \\t]*$`);
+            // Consume lines up to (and including) the closing fence; an unclosed
+            // fence runs to EOF. Either way the whole span is one code segment.
+            let fenceText = line;
+            let cursor = lineEnd;
+            while (cursor < body.length) {
+                let nextEnd = body.indexOf('\n', cursor);
+                if (nextEnd === -1)
+                    nextEnd = body.length;
+                else
+                    nextEnd += 1;
+                const nextLine = body.slice(cursor, nextEnd);
+                fenceText += nextLine;
+                cursor = nextEnd;
+                // The `\r?\n` strip here is LOAD-BEARING — do NOT remove it. `closeRegex`
+                // ends in `[ \t]*$` and is built with no `m` flag, so its `$` anchors at
+                // end-of-string. `nextLine` still carries its trailing newline (we keep
+                // it for a byte-identical re-join), and `[ \t]*` cannot consume a `\n`,
+                // so without the strip the close test fails on every newline-terminated
+                // fence line (CRLF or LF). The fence would then run to EOF, wrongly
+                // swallowing text that follows the closing fence into the code segment.
+                // (An EOF-only fence happens to pass either way because `$` also matches
+                // end-of-string — which is why a content-after-close-fence test is what
+                // actually guards this. See code-mask.test.ts.)
+                if (closeRegex.test(nextLine.replace(/\r?\n$/, '')))
+                    break;
+            }
+            segments.push({ code: true, text: fenceText });
+            lineStart = cursor;
+            continue;
+        }
+        pendingText += line;
+        lineStart = lineEnd;
+    }
+    flushPendingText();
+    // The common "no code at all" body yields exactly one `{ code: false }`
+    // segment (the whole body, via `splitInlineCode`'s trailing `pushPlain`), so
+    // the caller's by-reference cheap-skip still works on the re-join.
+    return segments;
+}
+/**
+ * Apply `fn` only to the non-code segments of `body`, re-joining in original
+ * order. Returns `body` BY REFERENCE when `fn` left every non-code segment
+ * unchanged (preserving the caller's `result === body` cheap-skip for
+ * isPending). Code regions (fenced + inline, per `splitCodeSegments`) are
+ * passed through byte-identical.
+ *
+ * `fn` may be impure (carry an accumulator in a closure) — e.g. a `body.replace`
+ * callback that pushes occurrences / bumps counts. It is invoked once per
+ * non-code segment in document order; the code segments between them are never
+ * passed to `fn`, so a token written as a code example stays untouched and is
+ * never misdetected.
+ *
+ * This is the shared entry point for all three body-rewrite migrations
+ * (`wikilink-format`, `files-url-to-attachments`, `wikilink-html-recover`); the
+ * segment-and-rewrite scheme (vs. a fill/restore one) is justified in this
+ * file's header. The by-reference cheap-skip is owned here, via per-segment
+ * `!==` identity tracking, so a caller that still keeps its own accumulator
+ * guard stays consistent (both agree on "changed").
+ */
+function rewriteOutsideCode(body, fn) {
+    let changed = false;
+    const out = splitCodeSegments(body).map((seg) => {
+        if (seg.code)
+            return seg.text;
+        const next = fn(seg.text);
+        if (next !== seg.text)
+            changed = true;
+        return next;
+    });
+    return changed ? out.join('') : body;
+}
+/**
+ * Split a run of non-fence text into inline-code (`code: true`) and plain
+ * (`code: false`) segments per CommonMark §6.1: an opening run of N backticks
+ * closed by the next run of *exactly* N backticks is a code span. An unmatched
+ * backtick run stays literal (folded into the surrounding plain segment).
+ */
+function splitInlineCode(text) {
+    const segments = [];
+    let plainStart = 0;
+    let i = 0;
+    const pushPlain = (end) => {
+        if (end > plainStart)
+            segments.push({ code: false, text: text.slice(plainStart, end) });
+    };
+    while (i < text.length) {
+        if (text[i] !== '`') {
+            i += 1;
+            continue;
+        }
+        // Measure the opening backtick run length.
+        const openStart = i;
+        let runLen = 0;
+        while (i < text.length && text[i] === '`') {
+            runLen += 1;
+            i += 1;
+        }
+        // Look for a closing run of exactly `runLen` backticks.
+        let scan = i;
+        let closeStart = -1;
+        while (scan < text.length) {
+            if (text[scan] !== '`') {
+                scan += 1;
+                continue;
+            }
+            let closeLen = 0;
+            const thisRunStart = scan;
+            while (scan < text.length && text[scan] === '`') {
+                closeLen += 1;
+                scan += 1;
+            }
+            if (closeLen === runLen) {
+                closeStart = thisRunStart;
+                break;
+            }
+            // A run of a different length is not a valid closer; keep scanning.
+        }
+        if (closeStart === -1) {
+            // Unmatched opener — leave the backtick run as literal text and continue
+            // scanning from just after it (so a later valid span is still found).
+            continue;
+        }
+        // Emit the plain text before the span, then the span itself.
+        pushPlain(openStart);
+        const spanEnd = closeStart + runLen;
+        segments.push({ code: true, text: text.slice(openStart, spanEnd) });
+        plainStart = spanEnd;
+        i = spanEnd;
+    }
+    pushPlain(text.length);
+    return segments;
+}
+//# sourceMappingURL=code-mask.js.map

package/dist/migration/migrations/code-mask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-mask.js","sourceRoot":"","sources":["../../../src/migration/migrations/code-mask.ts"],"names":[],"mappings":"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"}

package/dist/migration/migrations/files-url-to-attachments.d.ts

@@ -0,0 +1,99 @@
+import type { MigrationContext } from '../types';
+/**
+ * Per-body breakdown of what a rewrite touched / skipped, returned alongside
+ * the rewritten body so callers walk the regex once.
+ *   - `relative`: rule 1 (relative `/files/<id>`) rewrites.
+ *   - `selfHostAbsolute`: rule 2 (self-host absolute) rewrites.
+ *   - `externalSkipped`: rule 3 (external absolute) left untouched.
+ */
+export interface FilesUrlRewriteCounts {
+    relative: number;
+    selfHostAbsolute: number;
+    externalSkipped: number;
+}
+/**
+ * Single-pass detect-and-rewrite. Returns the rewritten body plus a count
+ * breakdown so callers don't walk the regex twice. Pure — no I/O. Returns
+ * `body` by reference when nothing changed (no rule-1/2 rewrite), letting
+ * callers cheap-skip via `result.body === body`.
+ *
+ * `origins` is the self-host allow-list (`getAppOrigins()`); pass `[]` to
+ * disable rule 2 (CLIENT_URL / BASE_URL unset).
+ *
+ * Code regions (fenced blocks + inline spans) are excluded via the shared
+ * `rewriteOutsideCode` primitive: a `/files/<id>` written as a code example is
+ * left byte-identical (never rewritten, never counted) so it cannot be
+ * corrupted, nor falsely report the migration as pending. Indented code is an
+ * accepted divergence (still rewritten). AD-2 (an `![alt](url)` whose alt text
+ * contains an inline-code span straddles a segment boundary, leaving its URL
+ * unrewritten) is documented in the spec — an accepted false-negative.
+ */
+export declare function rewriteFilesUrls(body: string, origins: readonly string[]): {
+    body: string;
+    counts: FilesUrlRewriteCounts;
+};
+/**
+ * True iff `body` holds at least one *rewritable* v1 file URL — a relative
+ * `/files/<id>` or a self-host absolute one (external-only bodies report
+ * false). `/files/` is a cheap prefilter so bodies that can't contain one skip
+ * the regex; the verdict itself is the full rule (external skips don't count)
+ * so a body whose only `/files/<id>` is external correctly reports false.
+ * Shared by `isPending` and `collectRewritablePages`.
+ */
+export declare function bodyHasRewritableFilesUrl(body: string, origins: readonly string[]): boolean;
+export declare const filesUrlToAttachments: {
+    id: string;
+    fromVersion: string;
+    toVersion: string;
+    layer: "preflight";
+    severity: "cosmetic";
+    description: string;
+    /**
+     * Pending verdict = at least one published page whose **current** revision
+     * body still contains a rewritable v1 file URL. Mirrors `wikilink-format`:
+     *
+     *  1. The verdict uses the **full rule** (`bodyHasRewritableFilesUrl`), not
+     *     the bare substring. `/files/` could appear in an external URL we leave
+     *     alone (rule 3); counting that would report pending forever after apply
+     *     (apply only rewrites self URLs), deadlocking boot under preflight +
+     *     `block`. The full rule reports false once only external `/files/`
+     *     references remain, so boot clears.
+     *  2. We scan only each page's **current** revision, never the whole
+     *     `revisions` collection — historical revisions keep their original
+     *     `/files/<id>` text forever (immutable), so a collection-wide scan
+     *     would pend permanently after any such page ever existed.
+     *
+     * Short-circuits at the first rewritable page.
+     */
+    isPending: (ctx: MigrationContext) => Promise<boolean>;
+    /**
+     * Full scan for `plan`: affected page count plus the rewrite breakdown
+     * (relative / self-host absolute rewrites + external skips, the last
+     * aggregated across every `/files/` page — see `scanFilesUrls`). Not called
+     * at boot.
+     */
+    detect: (ctx: MigrationContext) => Promise<{
+        summary: string;
+        counts: {
+            pages: number;
+            rewrites: number;
+            relative: number;
+            selfHostAbsolute: number;
+            externalSkipped: number;
+        };
+    }>;
+    stages: {
+        name: string;
+        fn: (ctx: MigrationContext) => Promise<{
+            name: string;
+            transformed: number;
+            stats: {
+                wouldRewrite: number;
+            };
+        } | {
+            name: string;
+            transformed: number;
+            stats?: undefined;
+        }>;
+    }[];
+};

package/dist/migration/migrations/files-url-to-attachments.js

@@ -0,0 +1,305 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filesUrlToAttachments = void 0;
+exports.rewriteFilesUrls = rewriteFilesUrls;
+exports.bodyHasRewritableFilesUrl = bodyHasRewritableFilesUrl;
+const linkDetector_1 = __importDefault(require("../../util/linkDetector"));
+const page_1 = require("../../models/page");
+const helpers_1 = require("../helpers");
+const types_1 = require("../types");
+const code_mask_1 = require("./code-mask");
+/**
+ * v1 → v2 — `files-url-to-attachments` (preflight layer).
+ *
+ * v1 embedded attachment / image references in page bodies as the v1 file
+ * URL `/files/<24hex>` (absolute `https://<host>/files/<id>` when the editor
+ * pasted a full URL, or relative `/files/<id>`). v2 serves attachments from a
+ * dedicated stream route at `/api/v2/attachments/<id>` and the legacy
+ * `/files/<id>` compat redirect was removed with the Express host (RFC-0006
+ * Phase 6 Sub-batch D), so those v1 URLs now 404 — every such image is
+ * broken. The id is identical in both forms (the same 24-hex `Attachment._id`;
+ * `attachment.ts` `ATTACHMENT_URI_RE` extracts the same id from either), so the
+ * fix is a pure URL rewrite — no id mapping.
+ *
+ * Modelled on `wikilink-format.ts` (the sibling v1→v2 body-rewrite preflight):
+ * walk published (+ legacy `null`) pages, rewrite each current-revision body
+ * with a single-pass detect-and-rewrite, route every write through
+ * `ctx.rewritePageBody` (the `updatePage`-equivalent path that nulls
+ * `yjsState` / `yjsCheckpointAt` so an active editor can't revert the rewrite
+ * from a stale `Y.Doc` — see wikilink-format §4.3.1), and use a cheap
+ * substring prefilter (`/files/`) before the detail regex in `isPending`.
+ *
+ * Rewrite rules (Markdown `![alt](url)` images and `[text](url)` links only —
+ * raw HTML `<img src>` / `<a href>` is out of scope; v1 emitted Markdown):
+ *
+ *   1. relative `/files/<id>`                  → `/api/v2/attachments/<id>`
+ *      (unconditional — a root-relative path is always this site).
+ *   2. self-host absolute `https://<origin>/files/<id>`
+ *                                              → `/api/v2/attachments/<id>`
+ *      (relativised — drops the host so the URL is portable). `<origin>` must
+ *      match `linkDetector.getAppOrigins()` (CLIENT_URL / BASE_URL).
+ *   3. external absolute `https://other/files/<id>` → left untouched
+ *      (we must not rewrite an unrelated third-party `/files/<id>` image).
+ *
+ * Host moves (v1 domain ≠ v2 domain) are out of scope: the separate `replace
+ * url` admin-cli command rewrites the old host → new host first, after which
+ * the self-host absolute URLs match CLIENT_URL and rule 2 relativises them.
+ *
+ * Idempotent: the output `/api/v2/attachments/<id>` never matches the
+ * `/files/` regex, so a re-apply is a no-op (no double rewrite).
+ *
+ * CLIENT_URL / BASE_URL unset: `getAppOrigins()` returns `[]`, so the
+ * self-host alternation is empty and rule 2 is skipped — only relative
+ * `/files/<id>` (rule 1) is rewritten and absolute URLs are left alone.
+ */
+/** v2 attachment URL prefix the rewrite targets. */
+const V2_ATTACHMENT_PREFIX = '/api/v2/attachments/';
+/**
+ * Substring that necessarily precedes every rewritable v1 file URL: `/files/`.
+ * Cheapest probe guaranteed present whenever a real `/files/<id>` reference
+ * exists, so a body without it can skip the regex entirely (no false
+ * negatives). The actual verdict still applies the full detect rule — see
+ * `bodyHasRewritableFilesUrl`.
+ */
+const FILES_SUBSTRING_PROBE = '/files/';
+const emptyCounts = () => ({ relative: 0, selfHostAbsolute: 0, externalSkipped: 0 });
+/**
+ * Build the per-body rewrite regex. It matches a Markdown image/link whose URL
+ * payload points at `/files/<24hex>` in one of two forms:
+ *
+ *   - relative: the URL part starts with `/files/<id>`
+ *   - absolute: the URL part is `<scheme>://<host>.../files/<id>`
+ *
+ * The `![alt]` / `[text]` head and the trailing path/query/fragment after the
+ * id are captured verbatim and re-emitted unchanged; only the host + `/files/`
+ * → `/api/v2/attachments/` portion is rewritten. Self-host classification of
+ * absolute URLs is decided in the callback (not the regex) so external hosts
+ * fall through untouched.
+ *
+ * A fresh `RegExp` per call keeps `lastIndex` state local (the regex is `g`).
+ */
+function buildFilesUrlRegex() {
+    // Group layout:
+    //   1: the markdown head `![alt]` or `[text]` (incl. the leading `!` if image)
+    //   2: optional `<scheme>://<host>` for an absolute URL (undefined when relative)
+    //   3: the 24-hex attachment id
+    //   4: the trailing remainder inside the parens after the id (path/query/#),
+    //      excluding the closing `)` and whitespace
+    return /(!?\[[^\]]*\])\((https?:\/\/[^\s)/]+)?\/files\/([0-9a-fA-F]{24})([^\s)]*)\)/g;
+}
+/**
+ * Decide whether an absolute URL's `<scheme>://<host>` prefix belongs to this
+ * Crowi instance. `origins` are the normalised `getAppOrigins()` values
+ * (trailing slash trimmed). A match means the URL is self-host and should be
+ * relativised (rule 2); a non-match is external and left untouched (rule 3).
+ *
+ * The match is exact against the captured `<scheme>://<host>` (no path), so
+ * `https://wiki.example.com` matches origin `https://wiki.example.com` but not
+ * `https://evil.example.com`.
+ */
+function isSelfHostOrigin(schemeAndHost, origins) {
+    return origins.includes(schemeAndHost);
+}
+/**
+ * Single-pass detect-and-rewrite. Returns the rewritten body plus a count
+ * breakdown so callers don't walk the regex twice. Pure — no I/O. Returns
+ * `body` by reference when nothing changed (no rule-1/2 rewrite), letting
+ * callers cheap-skip via `result.body === body`.
+ *
+ * `origins` is the self-host allow-list (`getAppOrigins()`); pass `[]` to
+ * disable rule 2 (CLIENT_URL / BASE_URL unset).
+ *
+ * Code regions (fenced blocks + inline spans) are excluded via the shared
+ * `rewriteOutsideCode` primitive: a `/files/<id>` written as a code example is
+ * left byte-identical (never rewritten, never counted) so it cannot be
+ * corrupted, nor falsely report the migration as pending. Indented code is an
+ * accepted divergence (still rewritten). AD-2 (an `![alt](url)` whose alt text
+ * contains an inline-code span straddles a segment boundary, leaving its URL
+ * unrewritten) is documented in the spec — an accepted false-negative.
+ */
+function rewriteFilesUrls(body, origins) {
+    const counts = emptyCounts();
+    const rewriteSegment = (text) => text.replace(buildFilesUrlRegex(), (whole, head, schemeAndHost, id, rest) => {
+        if (schemeAndHost === undefined) {
+            // Rule 1 — relative `/files/<id>` is unconditionally this site.
+            counts.relative += 1;
+            return `${head}(${V2_ATTACHMENT_PREFIX}${id}${rest})`;
+        }
+        if (isSelfHostOrigin(schemeAndHost, origins)) {
+            // Rule 2 — self-host absolute URL; relativise (drop the host).
+            counts.selfHostAbsolute += 1;
+            return `${head}(${V2_ATTACHMENT_PREFIX}${id}${rest})`;
+        }
+        // Rule 3 — external host; leave untouched.
+        counts.externalSkipped += 1;
+        return whole;
+    });
+    const rewritten = (0, code_mask_1.rewriteOutsideCode)(body, rewriteSegment);
+    const changed = counts.relative > 0 || counts.selfHostAbsolute > 0;
+    return { body: changed ? rewritten : body, counts };
+}
+/**
+ * True iff `body` holds at least one *rewritable* v1 file URL — a relative
+ * `/files/<id>` or a self-host absolute one (external-only bodies report
+ * false). `/files/` is a cheap prefilter so bodies that can't contain one skip
+ * the regex; the verdict itself is the full rule (external skips don't count)
+ * so a body whose only `/files/<id>` is external correctly reports false.
+ * Shared by `isPending` and `collectRewritablePages`.
+ */
+function bodyHasRewritableFilesUrl(body, origins) {
+    if (!body.includes(FILES_SUBSTRING_PROBE))
+        return false;
+    const { counts } = rewriteFilesUrls(body, origins);
+    return counts.relative > 0 || counts.selfHostAbsolute > 0;
+}
+/**
+ * The self-host origins for the current instance, via the same
+ * `linkDetector.getAppOrigins()` helper backlink classification uses
+ * (CLIENT_URL + BASE_URL, trailing slash trimmed, deduped). Returns `[]` when
+ * neither is configured — rule 2 is then disabled (relative-only rewrite).
+ */
+function resolveAppOrigins(ctx) {
+    return (0, linkDetector_1.default)(ctx.crowi).getAppOrigins();
+}
+/**
+ * One full scan of every published (+ legacy `null`) page (trash & deprecated
+ * are read-only fixtures — same scope as `wikilink-format`). Returns:
+ *   - `rewritable`: the pages that actually change (≥1 relative / self-host
+ *     rewrite), each with its rewritten body for `ctx.rewritePageBody`.
+ *   - `totals`: the rewrite breakdown aggregated across **every** page with a
+ *     `/files/` reference (so `externalSkipped` reflects external URLs even on
+ *     pages with no rewritable URL — an operator signal for "why some /files/
+ *     references remain").
+ * Stream-walks so memory stays constant on large installs.
+ */
+async function scanFilesUrls(ctx, origins) {
+    const Page = ctx.crowi.model('Page');
+    const Revision = ctx.crowi.model('Revision');
+    const rewritable = [];
+    const totals = emptyCounts();
+    const cursor = Page.find({ $or: [{ status: page_1.STATUS_PUBLISHED }, { status: null }] })
+        .select('_id revision')
+        .lean()
+        .cursor();
+    for await (const page of cursor) {
+        const pageDoc = page;
+        if (!pageDoc.revision)
+            continue;
+        const revision = await Revision.findById(pageDoc.revision).select('body').lean().exec();
+        const body = revision?.body;
+        if (typeof body !== 'string')
+            continue;
+        if (!body.includes(FILES_SUBSTRING_PROBE))
+            continue;
+        const result = rewriteFilesUrls(body, origins);
+        totals.relative += result.counts.relative;
+        totals.selfHostAbsolute += result.counts.selfHostAbsolute;
+        totals.externalSkipped += result.counts.externalSkipped;
+        if (result.body === body)
+            continue;
+        rewritable.push({ pageId: String(pageDoc._id), newBody: result.body, counts: result.counts });
+    }
+    return { rewritable, totals };
+}
+exports.filesUrlToAttachments = (0, types_1.defineMigration)({
+    id: 'files-url-to-attachments',
+    fromVersion: '1.x',
+    toVersion: '2.1',
+    layer: 'preflight',
+    // Body URL rewrite only; a `/files/<id>` → 302 fallback keeps pages working
+    // even unapplied. `isPending` scans the live corpus → re-triggers on new
+    // content. Cosmetic.
+    severity: 'cosmetic',
+    description: 'Rewrite v1 /files/<id> attachment URLs to v2 /api/v2/attachments/<id>',
+    /**
+     * Pending verdict = at least one published page whose **current** revision
+     * body still contains a rewritable v1 file URL. Mirrors `wikilink-format`:
+     *
+     *  1. The verdict uses the **full rule** (`bodyHasRewritableFilesUrl`), not
+     *     the bare substring. `/files/` could appear in an external URL we leave
+     *     alone (rule 3); counting that would report pending forever after apply
+     *     (apply only rewrites self URLs), deadlocking boot under preflight +
+     *     `block`. The full rule reports false once only external `/files/`
+     *     references remain, so boot clears.
+     *  2. We scan only each page's **current** revision, never the whole
+     *     `revisions` collection — historical revisions keep their original
+     *     `/files/<id>` text forever (immutable), so a collection-wide scan
+     *     would pend permanently after any such page ever existed.
+     *
+     * Short-circuits at the first rewritable page.
+     */
+    isPending: async (ctx) => {
+        const origins = resolveAppOrigins(ctx);
+        const Page = ctx.crowi.model('Page');
+        const Revision = ctx.crowi.model('Revision');
+        const cursor = Page.find({ $or: [{ status: page_1.STATUS_PUBLISHED }, { status: null }] })
+            .select('_id revision')
+            .lean()
+            .cursor();
+        for await (const page of cursor) {
+            const revisionId = page.revision;
+            if (!revisionId)
+                continue;
+            const revision = await Revision.findById(revisionId).select('body').lean().exec();
+            const body = revision?.body;
+            if (typeof body === 'string' && bodyHasRewritableFilesUrl(body, origins)) {
+                await cursor.close();
+                return true;
+            }
+        }
+        return false;
+    },
+    /**
+     * Full scan for `plan`: affected page count plus the rewrite breakdown
+     * (relative / self-host absolute rewrites + external skips, the last
+     * aggregated across every `/files/` page — see `scanFilesUrls`). Not called
+     * at boot.
+     */
+    detect: async (ctx) => {
+        const origins = resolveAppOrigins(ctx);
+        const { rewritable, totals } = await scanFilesUrls(ctx, origins);
+        const rewrites = totals.relative + totals.selfHostAbsolute;
+        return {
+            summary: `${rewritable.length} page(s) need a v1 /files/<id> rewrite (${rewrites} rewrite(s): ${totals.relative} relative, ${totals.selfHostAbsolute} self-host absolute; ${totals.externalSkipped} external skipped)`,
+            counts: {
+                pages: rewritable.length,
+                rewrites,
+                relative: totals.relative,
+                selfHostAbsolute: totals.selfHostAbsolute,
+                externalSkipped: totals.externalSkipped,
+            },
+        };
+    },
+    stages: [
+        {
+            name: 'rewrite-files-url',
+            fn: async (ctx) => {
+                const origins = resolveAppOrigins(ctx);
+                if (ctx.dryRun) {
+                    const { rewritable } = await scanFilesUrls(ctx, origins);
+                    return { name: 'rewrite-files-url', transformed: 0, stats: { wouldRewrite: rewritable.length } };
+                }
+                const actingUserId = await (0, helpers_1.resolveActingUserId)(ctx, 'files-url-to-attachments');
+                const { rewritable: pages } = await scanFilesUrls(ctx, origins);
+                ctx.progress.setTotal(pages.length);
+                let rewritten = 0;
+                // Serial walk through `ctx.rewritePageBody` (each call re-fetches the
+                // live page, prepares a revision, and pushes it via the updatePage
+                // path so yjsState / yjsCheckpointAt are nulled).
+                for (const page of pages) {
+                    await ctx.rewritePageBody(page.pageId, page.newBody, { userId: actingUserId });
+                    rewritten += 1;
+                    ctx.progress.increment();
+                }
+                if (rewritten > 0) {
+                    ctx.logger.info(`files-url-to-attachments: rewrote ${rewritten} page(s) via the updatePage path (yjsState invalidated)`);
+                }
+                return { name: 'rewrite-files-url', transformed: rewritten };
+            },
+        },
+    ],
+});
+//# sourceMappingURL=files-url-to-attachments.js.map

package/dist/migration/migrations/files-url-to-attachments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-url-to-attachments.js","sourceRoot":"","sources":["../../../src/migration/migrations/files-url-to-attachments.ts"],"names":[],"mappings":"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"}