@crowi/api 2.0.0-alpha.0

package/dist/migration/migrations/wikilink-format.js

@@ -0,0 +1,418 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wikilinkFormat = exports.WIKILINK_DETECTION_REGEX = exports.KNOWN_HTML_ELEMENTS = void 0;
+exports.bodyHasRewritableWikilink = bodyHasRewritableWikilink;
+exports.shouldRewriteWikilink = shouldRewriteWikilink;
+exports.rewriteAndDetect = rewriteAndDetect;
+exports.rewriteWikilinks = rewriteWikilinks;
+const page_1 = require("../../models/page");
+const types_1 = require("../types");
+/**
+ * RFC-0008 §10.2 step 4 / §4.3.1 — `wikilink-format` (preflight layer).
+ *
+ * Ported from the former standalone `crowi-admin migrate --only=wikilink`
+ * (`packages/admin-cli/src/commands/migrate-wikilink.ts`). The migration
+ * rewrites v1 angle-bracket internal links (`</path>` / `</path|alias>`) to
+ * the v2 wikilink form (`[[path]]` / `[[path|alias]]`).
+ *
+ * Why this is a migration (not just a CLI command): the old command called
+ * `Revision.prepareRevision` + `Page.pushRevision` directly, bypassing
+ * `Page.updatePage`. That path never nulls `yjsState` / `yjsCheckpointAt`, so
+ * any user editing a rewritten page stayed pinned to a stale `Y.Doc` and could
+ * silently revert the migration on their next autosave (RFC-0008 §4.3.1
+ * "Motivating bug"). Routing every body rewrite through `ctx.rewritePageBody`
+ * (= the `updatePage`-equivalent path) repoints `currentRevision` and nulls the
+ * Yjs snapshot, so the next `onLoadDocument` rebuilds from the new body. As a
+ * preflight migration this is persistence-only (no live force-reload broadcast):
+ * preflight runs in a maintenance window with no connected editors (§4.3.1).
+ *
+ * The textual conversion logic below is moved verbatim from the old command so
+ * the rewrite output is byte-identical to the legacy migrator.
+ */
+/**
+ * HTML5 element name set used to reject `</foo>` matches whose first path
+ * segment is actually a closing HTML tag. Source:
+ * https://developer.mozilla.org/en-US/docs/Web/HTML/Element — the full
+ * standard element list as of the HTML Living Standard.
+ *
+ * Kept as a top-level `Set<string>` so detection runs O(1) per match.
+ * `h1`..`h6` are listed explicitly because the regex captures `foo` for
+ * `</foo>` and we want both `</h1>` and `</h6>` to be rejected.
+ */
+exports.KNOWN_HTML_ELEMENTS = new Set([
+    'a',
+    'abbr',
+    'address',
+    'area',
+    'article',
+    'aside',
+    'audio',
+    'b',
+    'base',
+    'bdi',
+    'bdo',
+    'blockquote',
+    'body',
+    'br',
+    'button',
+    'canvas',
+    'caption',
+    'cite',
+    'code',
+    'col',
+    'colgroup',
+    'data',
+    'datalist',
+    'dd',
+    'del',
+    'details',
+    'dfn',
+    'dialog',
+    'div',
+    'dl',
+    'dt',
+    'em',
+    'embed',
+    'fieldset',
+    'figcaption',
+    'figure',
+    'footer',
+    'form',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'head',
+    'header',
+    'hgroup',
+    'hr',
+    'html',
+    'i',
+    'iframe',
+    'img',
+    'input',
+    'ins',
+    'kbd',
+    'label',
+    'legend',
+    'li',
+    'link',
+    'main',
+    'map',
+    'mark',
+    'menu',
+    'meta',
+    'meter',
+    'nav',
+    'noscript',
+    'object',
+    'ol',
+    'optgroup',
+    'option',
+    'output',
+    'p',
+    'picture',
+    'pre',
+    'progress',
+    'q',
+    'rp',
+    'rt',
+    'ruby',
+    's',
+    'samp',
+    'script',
+    'section',
+    'select',
+    'slot',
+    'small',
+    'source',
+    'span',
+    'strong',
+    'style',
+    'sub',
+    'summary',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'template',
+    'textarea',
+    'tfoot',
+    'th',
+    'thead',
+    'time',
+    'title',
+    'tr',
+    'track',
+    'u',
+    'ul',
+    'var',
+    'video',
+    'wbr',
+]);
+/**
+ * v1 angle-bracket internal link form. The capture group grabs the path-style
+ * payload (starts with `/`, no whitespace, no `<` / `>` / `|` other than the
+ * optional `|alias` segment). See `packages/api/src/util/linkDetector.ts` — v1
+ * used `<(/[^>]+)>` for the same primitive; we tighten it here to:
+ *
+ *   - leading `/` to keep this strictly path-style (not arbitrary text)
+ *   - no whitespace inside the **path** (Crowi page paths cannot contain spaces)
+ *   - no `<` / `>` until the closing `>` and no `|` until the optional alias
+ *   - optional `|alias` (free-form text, no `<` / `>`)
+ *
+ * Detection only — see `shouldRewriteWikilink` for the HTML-element filter.
+ */
+exports.WIKILINK_DETECTION_REGEX = /<(\/[^\s<>|]+)(\|[^<>]+)?>/g;
+/**
+ * Substring that necessarily precedes every legacy wikilink: `</` (the match is
+ * `<` followed by the path's leading `/`, e.g. `</docs/api>`). HTML close tags
+ * (`</div>`) share this prefix, so this is a *prefilter* only — it is the
+ * cheapest substring guaranteed present whenever a real legacy wikilink exists
+ * (so it never yields a false negative), letting us skip the regex on bodies
+ * that obviously cannot contain one. The actual pending *verdict* applies the
+ * full `shouldRewriteWikilink` rule — see `bodyHasRewritableWikilink`.
+ */
+const WIKILINK_SUBSTRING_PROBE = '</';
+/**
+ * True iff `body` contains at least one *genuine* legacy wikilink — i.e. a
+ * `</...>` match that survives the full `shouldRewriteWikilink` HTML-element
+ * filter. `</div>` and other close tags return false.
+ *
+ * `</` is used as a cheap prefilter so bodies that cannot possibly contain a
+ * legacy wikilink skip the regex entirely; the verdict itself is the full
+ * detection rule (not the substring), so a body whose only `</` occurrences are
+ * HTML close tags correctly reports false. Shared by `isPending` (current-
+ * revision verdict) and `collectRewritablePages` (full detect/stage scan) so
+ * the detection logic lives in one place.
+ */
+function bodyHasRewritableWikilink(body) {
+    if (!body.includes(WIKILINK_SUBSTRING_PROBE))
+        return false;
+    return rewriteAndDetect(body).occurrences.length > 0;
+}
+/**
+ * Decide whether a detected `</...>` match is a v1 wikilink we should rewrite,
+ * or a coincidental HTML close tag we must leave alone.
+ *
+ * The rule: reject when the **first path segment** (everything between the
+ * leading `/` and the next `/`, `#`, or end-of-payload) is a known HTML element
+ * name (lowercased). Crowi page paths are case-sensitive, so `</Section>` is a
+ * wikilink (page `Section`) while `</section>` is the HTML element.
+ */
+function shouldRewriteWikilink(innerPath) {
+    if (innerPath === '/')
+        return false;
+    if (!innerPath.startsWith('/'))
+        return false;
+    const afterLeadingSlash = innerPath.slice(1);
+    const firstSegmentEnd = afterLeadingSlash.search(/[/#]/);
+    const firstSegment = firstSegmentEnd === -1 ? afterLeadingSlash : afterLeadingSlash.slice(0, firstSegmentEnd);
+    if (firstSegment.length === 0)
+        return false;
+    // Only reject lowercase-ASCII first segments that are real HTML elements.
+    if (!/^[a-z][a-z0-9]*$/.test(firstSegment))
+        return true;
+    return !exports.KNOWN_HTML_ELEMENTS.has(firstSegment);
+}
+/**
+ * Single-pass detect-and-rewrite. Returns the rewritten body together with the
+ * occurrence list so callers don't walk the regex twice. `body` is returned by
+ * reference when nothing changed, letting callers cheap-skip via
+ * `result.body === body`. Pure function — no side effects, no I/O.
+ */
+function rewriteAndDetect(body) {
+    const occurrences = [];
+    const rewritten = body.replace(exports.WIKILINK_DETECTION_REGEX, (whole, innerPath, aliasWithPipe) => {
+        if (!shouldRewriteWikilink(innerPath))
+            return whole;
+        occurrences.push({
+            raw: whole,
+            path: innerPath,
+            alias: aliasWithPipe ? aliasWithPipe.slice(1) : undefined,
+        });
+        const aliasSegment = aliasWithPipe ?? '';
+        return `[[${innerPath}${aliasSegment}]]`;
+    });
+    return { body: occurrences.length === 0 ? body : rewritten, occurrences };
+}
+/**
+ * Convenience wrapper for tests / callers that only need the rewritten body.
+ * The migration hot path uses `rewriteAndDetect` to avoid walking the regex
+ * twice.
+ */
+function rewriteWikilinks(body) {
+    return rewriteAndDetect(body).body;
+}
+/**
+ * Resolve which user is recorded as the author of every rewritten revision.
+ * The `updatePage`-equivalent path (`rewritePageBody`) ultimately calls
+ * `Revision.prepareRevision`, which **throws** when handed a falsy user, so a
+ * preflight rewrite MUST resolve a real acting user up front rather than rely
+ * on per-page `lastUpdateUser`/`creator` (those can dangle to a deleted user).
+ *
+ * Order, mirroring the legacy `migrate-wikilink` command:
+ *   1. `process.env.CROWI_MIGRATE_USER` — interpreted as an email; the named
+ *      user must exist.
+ *   2. otherwise the oldest admin user (`{ admin: true }` sorted by createdAt),
+ *      deterministic across re-runs.
+ *
+ * Throws when neither yields a user so the operator gets a clear error instead
+ * of a per-page `user should have _id` failure deep inside the rewrite.
+ */
+async function resolveActingUserId(ctx) {
+    const User = ctx.crowi.model('User');
+    const explicit = process.env.CROWI_MIGRATE_USER;
+    if (explicit) {
+        const named = await User.findOne({ email: explicit }).select('_id').lean().exec();
+        if (named)
+            return String(named._id);
+        throw new Error(`CROWI_MIGRATE_USER='${explicit}' but no user with that email exists.`);
+    }
+    const admin = await User.findOne({ admin: true }).sort({ createdAt: 1 }).select('_id').lean().exec();
+    if (admin)
+        return String(admin._id);
+    throw new Error('wikilink-format: no admin user found; set CROWI_MIGRATE_USER=<email> or create an admin user first.');
+}
+/**
+ * Walk every published page, keep those whose current revision body holds a
+ * genuine legacy wikilink (`bodyHasRewritableWikilink` — the same full
+ * `shouldRewriteWikilink` rule `isPending` uses, with `</` as a cheap
+ * prefilter), and pair each with its rewritten body + occurrence count for
+ * `ctx.rewritePageBody`.
+ *
+ * Restricted to `status: 'published'` (and legacy `null`, treated as published)
+ * because trash / deprecated pages are read-only fixtures — touching them would
+ * generate noisy update events, matching the legacy command's scope.
+ */
+async function collectRewritablePages(ctx) {
+    const Page = ctx.crowi.model('Page');
+    const Revision = ctx.crowi.model('Revision');
+    const out = [];
+    // `currentRevision ?? revision` is the body the editor seeds from
+    // (on-load-document.ts), but the legacy command read `page.revision`; both
+    // point at the latest body for a published page, so we read `revision` to
+    // keep parity. Stream-walk so memory stays constant on large installs.
+    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 (!bodyHasRewritableWikilink(body))
+            continue;
+        const result = rewriteAndDetect(body);
+        out.push({ pageId: String(pageDoc._id), newBody: result.body, occurrences: result.occurrences.length });
+    }
+    return out;
+}
+exports.wikilinkFormat = (0, types_1.defineMigration)({
+    id: 'wikilink-format',
+    fromVersion: '1.x',
+    toVersion: '2.1',
+    layer: 'preflight',
+    description: 'Migrate wikilink syntax',
+    /**
+     * Pending verdict = at least one published page whose **current** revision
+     * body still contains a genuine legacy wikilink. Two constraints shape this:
+     *
+     *  1. The verdict uses the **full detection rule**, not the bare substring.
+     *     A v1 wikilink (`</docs/api>`) and an HTML close tag (`</div>`) both
+     *     start with `</`, and there is no index on `revision.body`, so an
+     *     index-backed O(1) probe is impossible without a text index (which §9
+     *     says the framework does not own). We therefore walk published pages and
+     *     run `bodyHasRewritableWikilink` (the same `shouldRewriteWikilink` filter
+     *     used by `detect`/stage) on each current-revision body. `</` is kept only
+     *     as a cheap prefilter inside that helper to skip the regex on bodies that
+     *     obviously cannot contain a legacy link.
+     *
+     *     This is load-bearing for boot under preflight + `block` (the default):
+     *     the substring alone would over-match `</div>` and report pending forever
+     *     even after `migrate apply` — apply rewrites only genuine wikilinks, so
+     *     HTML close tags survive and a substring verdict would never clear,
+     *     deadlocking boot (§6.2: a false positive blocks every cluster boot, and
+     *     here it would be unrecoverable). Using the full rule means once the
+     *     migration rewrites the genuine wikilinks, a body left with only `</div>`
+     *     reports false and boot clears.
+     *  2. We scan only each page's **current** revision, never the whole
+     *     `revisions` collection. Historical revisions keep their original
+     *     `</path>` text forever (revisions are immutable), so a collection-wide
+     *     scan would report pending permanently after any wikilink page ever
+     *     existed — even once every live page was rewritten. So we read only the
+     *     body each page's editor seeds from.
+     *
+     * We short-circuit at the first page carrying a genuine wikilink, so this
+     * stops early rather than reading every page.
+     */
+    isPending: async (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' && bodyHasRewritableWikilink(body)) {
+                await cursor.close();
+                return true;
+            }
+        }
+        return false;
+    },
+    /**
+     * Full scan for `plan`: count the pages that actually contain a rewritable
+     * occurrence (applying the full `shouldRewriteWikilink` rule, not just the
+     * substring pre-filter), plus the total occurrence count. Not called at boot.
+     */
+    detect: async (ctx) => {
+        const pages = await collectRewritablePages(ctx);
+        const totalOccurrences = pages.reduce((sum, p) => sum + p.occurrences, 0);
+        return {
+            summary: `${pages.length} page(s) contain legacy wikilink syntax (${totalOccurrences} occurrence(s))`,
+            counts: { pages: pages.length, occurrences: totalOccurrences },
+        };
+    },
+    stages: [
+        {
+            name: 'rewrite-wikilink',
+            fn: async (ctx) => {
+                if (ctx.dryRun) {
+                    // Preview only — no writes, no acting-user resolution.
+                    const pages = await collectRewritablePages(ctx);
+                    return { name: 'rewrite-wikilink', transformed: 0, stats: { wouldRewrite: pages.length } };
+                }
+                const actingUserId = await resolveActingUserId(ctx);
+                const pages = await collectRewritablePages(ctx);
+                ctx.progress.setTotal(pages.length);
+                let rewritten = 0;
+                // Bounded concurrency is owned by the runner; the stage walks pages
+                // serially through `ctx.rewritePageBody` (each call re-fetches the live
+                // page doc, prepares a revision, and pushes it — routing through the
+                // `updatePage`-equivalent 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(`wikilink-format: rewrote ${rewritten} page(s) via the updatePage path (yjsState invalidated)`);
+                }
+                return { name: 'rewrite-wikilink', transformed: rewritten };
+            },
+        },
+    ],
+});
+//# sourceMappingURL=wikilink-format.js.map

package/dist/migration/migrations/wikilink-format.js.map

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

package/dist/migration/rebuild-api.d.ts

@@ -0,0 +1,50 @@
+import type Crowi from '../crowi';
+import { type RebuildOutcome } from './rebuild-runner';
+/**
+ * RFC-0008 §8.5 — the api-side surface the `@crowi/admin-cli` `rebuild`
+ * commands consume.
+ *
+ * Mirrors `cli-api.ts` (the `migrate` façade): the admin CLI is a separate
+ * process that `require`s the api's compiled `dist/`, so it talks to a small
+ * stable façade rather than reaching into `rebuild-runner.ts` / `rebuilds/`
+ * individually. Every entry point routes through `RebuildRunner` so dry-run /
+ * progress / SIGINT / structured logging are shared with `migrate` — but with
+ * NO `migrationApplications` coupling (§8.5: rebuilds have no pending/applied
+ * concept).
+ */
+/** Optional progress callback surfaced to the CLI (label + monotonically increasing count). */
+export interface RebuildProgress {
+    onLabel?: (label: string) => void;
+    onIncrement?: (current: number) => void;
+}
+export interface RebuildSearchOptions {
+    dryRun?: boolean;
+    progress?: RebuildProgress;
+}
+export interface RebuildStorageCopyOptions {
+    from: string;
+    to: string;
+    dryRun?: boolean;
+    progress?: RebuildProgress;
+}
+export interface RebuildRendererOptions {
+    onlyStale?: boolean;
+    dryRun?: boolean;
+    progress?: RebuildProgress;
+}
+export interface RebuildBacklinkOptions {
+    dryRun?: boolean;
+    progress?: RebuildProgress;
+}
+/** Façade over the rebuild runner + task registry for the CLI. */
+export declare class RebuildCliApi {
+    private readonly crowi;
+    constructor(crowi: Crowi);
+    private buildRunner;
+    rebuildSearch(opts?: RebuildSearchOptions): Promise<RebuildOutcome>;
+    rebuildStorageCopy(opts: RebuildStorageCopyOptions): Promise<RebuildOutcome>;
+    rebuildRenderer(opts?: RebuildRendererOptions): Promise<RebuildOutcome>;
+    rebuildBacklink(opts?: RebuildBacklinkOptions): Promise<RebuildOutcome>;
+}
+/** Convenience factory used by the CLI's `require(dist/migration/rebuild-api)`. */
+export declare function createRebuildCliApi(crowi: Crowi): RebuildCliApi;

package/dist/migration/rebuild-api.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RebuildCliApi = void 0;
+exports.createRebuildCliApi = createRebuildCliApi;
+const rebuild_runner_1 = require("./rebuild-runner");
+const rebuilds_1 = require("./rebuilds");
+/** Façade over the rebuild runner + task registry for the CLI. */
+class RebuildCliApi {
+    crowi;
+    constructor(crowi) {
+        this.crowi = crowi;
+    }
+    buildRunner(dryRun, progress) {
+        let count = 0;
+        return new rebuild_runner_1.RebuildRunner(this.crowi, {
+            dryRun,
+            progress: {
+                setTotal: () => undefined,
+                increment: (delta = 1) => {
+                    count += delta;
+                    progress?.onIncrement?.(count);
+                },
+                setLabel: (label) => progress?.onLabel?.(label),
+            },
+        });
+    }
+    rebuildSearch(opts = {}) {
+        return this.buildRunner(opts.dryRun, opts.progress).run(rebuilds_1.searchRebuild);
+    }
+    rebuildStorageCopy(opts) {
+        return this.buildRunner(opts.dryRun, opts.progress).run((0, rebuilds_1.storageCopyRebuild)({ from: opts.from, to: opts.to }));
+    }
+    rebuildRenderer(opts = {}) {
+        return this.buildRunner(opts.dryRun, opts.progress).run((0, rebuilds_1.rendererRebuild)({ onlyStale: opts.onlyStale ?? false }));
+    }
+    rebuildBacklink(opts = {}) {
+        return this.buildRunner(opts.dryRun, opts.progress).run(rebuilds_1.backlinkRebuild);
+    }
+}
+exports.RebuildCliApi = RebuildCliApi;
+/** Convenience factory used by the CLI's `require(dist/migration/rebuild-api)`. */
+function createRebuildCliApi(crowi) {
+    return new RebuildCliApi(crowi);
+}
+//# sourceMappingURL=rebuild-api.js.map

package/dist/migration/rebuild-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuild-api.js","sourceRoot":"","sources":["../../src/migration/rebuild-api.ts"],"names":[],"mappings":";;;AAqFA,kDAEC;AArFD,qDAAsE;AACtE,yCAAiG;AAyCjG,kEAAkE;AAClE,MAAa,aAAa;IACP,KAAK,CAAQ;IAE9B,YAAY,KAAY;QACtB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAEO,WAAW,CAAC,MAA2B,EAAE,QAAqC;QACpF,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,OAAO,IAAI,8BAAa,CAAC,IAAI,CAAC,KAAK,EAAE;YACnC,MAAM;YACN,QAAQ,EAAE;gBACR,QAAQ,EAAE,GAAG,EAAE,CAAC,SAAS;gBACzB,SAAS,EAAE,CAAC,KAAK,GAAG,CAAC,EAAE,EAAE;oBACvB,KAAK,IAAI,KAAK,CAAC;oBACf,QAAQ,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC;gBACjC,CAAC;gBACD,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC;aAChD;SACF,CAAC,CAAC;IACL,CAAC;IAED,aAAa,CAAC,OAA6B,EAAE;QAC3C,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,wBAAa,CAAC,CAAC;IACzE,CAAC;IAED,kBAAkB,CAAC,IAA+B;QAChD,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,IAAA,6BAAkB,EAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAChH,CAAC;IAED,eAAe,CAAC,OAA+B,EAAE;QAC/C,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,IAAA,0BAAe,EAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC;IACnH,CAAC;IAED,eAAe,CAAC,OAA+B,EAAE;QAC/C,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,0BAAe,CAAC,CAAC;IAC3E,CAAC;CACF;AArCD,sCAqCC;AAED,mFAAmF;AACnF,SAAgB,mBAAmB,CAAC,KAAY;IAC9C,OAAO,IAAI,aAAa,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC"}

package/dist/migration/rebuild-runner.d.ts

@@ -0,0 +1,64 @@
+import type Crowi from '../crowi';
+import { MigrationRunnerCore, type RunnerOptions } from './runner';
+import type { MigrationContext } from './types';
+/**
+ * RFC-0008 §8.5 — rebuild tasks.
+ *
+ * A *rebuild* regenerates derived data (search index / render cache /
+ * backlinks / a fresh copy of stored objects). Unlike a migration it is
+ * **version-independent** and has **no pending/applied concept** — it can run
+ * any time, any number of times. Consequently a rebuild MUST NOT touch the
+ * `migrationApplications` audit log: it shares the runner's *infrastructure*
+ * (dry-run / progress / bounded concurrency / SIGINT / structured logging /
+ * the per-run `MigrationContext`) via `MigrationRunnerCore`, but rides none of
+ * the migrate-only reconciliation/record path.
+ *
+ * This split keeps `MigrationRunner.apply` free of any `if (rebuild)` branch
+ * (the two namespaces are distinct subclasses of the shared core, not flags on
+ * one code path), and makes "rebuilds never write audit rows" a structural
+ * guarantee rather than a convention.
+ */
+/** Outcome of a single rebuild run, surfaced to the CLI for the summary block. */
+export interface RebuildOutcome {
+    /** Stable task id (e.g. 'search', 'storage-copy'). */
+    id: string;
+    durationMs: number;
+    /** True when SIGINT aborted the run before it finished. */
+    interrupted: boolean;
+    /** Free-form per-task result detail rendered by the CLI. */
+    stats: Record<string, unknown>;
+}
+/**
+ * A rebuild task. Receives the shared `MigrationContext` (dry-run / progress /
+ * logger / crowi) plus the owning runner so it can fan work out through the
+ * shared bounded-concurrency limiter and consult the SIGINT abort flag. It
+ * returns its own per-task stats — there is no audit record and no pending
+ * probe (§8.5).
+ */
+export interface RebuildTask {
+    /** Stable identifier for logs / summary (e.g. 'search'). */
+    id: string;
+    /** Short human-readable description. */
+    description: string;
+    /** Do the work. MUST no-op writes when `ctx.dryRun` is true. */
+    run(ctx: MigrationContext, runner: RebuildRunner): Promise<Record<string, unknown>>;
+}
+/**
+ * Identity helper mirroring `defineMigration` so a rebuild module gets
+ * inference from a single import.
+ */
+export declare function defineRebuild(task: RebuildTask): RebuildTask;
+/**
+ * The `rebuild`-namespace runner. Rides the shared `MigrationRunnerCore`
+ * (dry-run / progress / SIGINT / bounded concurrency / Yjs ctx) with **no**
+ * `migrationApplications` coupling (§8.5).
+ */
+export declare class RebuildRunner extends MigrationRunnerCore {
+    constructor(crowi: Crowi, options?: RunnerOptions);
+    /**
+     * Run one rebuild task through the shared infrastructure. Installs the
+     * SIGINT handler for the duration so a long rebuild can wind down safely,
+     * and never appends to the audit log (§8.5).
+     */
+    run(task: RebuildTask): Promise<RebuildOutcome>;
+}

package/dist/migration/rebuild-runner.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RebuildRunner = void 0;
+exports.defineRebuild = defineRebuild;
+const runner_1 = require("./runner");
+/**
+ * Identity helper mirroring `defineMigration` so a rebuild module gets
+ * inference from a single import.
+ */
+function defineRebuild(task) {
+    return task;
+}
+/**
+ * The `rebuild`-namespace runner. Rides the shared `MigrationRunnerCore`
+ * (dry-run / progress / SIGINT / bounded concurrency / Yjs ctx) with **no**
+ * `migrationApplications` coupling (§8.5).
+ */
+class RebuildRunner extends runner_1.MigrationRunnerCore {
+    constructor(crowi, options = {}) {
+        super(crowi, options);
+    }
+    /**
+     * Run one rebuild task through the shared infrastructure. Installs the
+     * SIGINT handler for the duration so a long rebuild can wind down safely,
+     * and never appends to the audit log (§8.5).
+     */
+    async run(task) {
+        const dispose = this.installSigintHandler();
+        const startedAt = Date.now();
+        try {
+            this.context.logger.info(`rebuild ${task.id}: ${task.description}${this.context.dryRun ? ' (dry-run)' : ''}`);
+            this.context.progress.setLabel(`rebuild:${task.id}`);
+            const stats = await task.run(this.context, this);
+            return { id: task.id, durationMs: Date.now() - startedAt, interrupted: this.aborted, stats };
+        }
+        finally {
+            dispose();
+        }
+    }
+}
+exports.RebuildRunner = RebuildRunner;
+//# sourceMappingURL=rebuild-runner.js.map

package/dist/migration/rebuild-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuild-runner.js","sourceRoot":"","sources":["../../src/migration/rebuild-runner.ts"],"names":[],"mappings":";;;AAsDA,sCAEC;AAtDD,qCAAmE;AAgDnE;;;GAGG;AACH,SAAgB,aAAa,CAAC,IAAiB;IAC7C,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAa,aAAc,SAAQ,4BAAmB;IACpD,YAAY,KAAY,EAAE,UAAyB,EAAE;QACnD,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,GAAG,CAAC,IAAiB;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,IAAI,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC9G,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;YACrD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACjD,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,EAAE,WAAW,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC;QAC/F,CAAC;gBAAS,CAAC;YACT,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;CACF;AAtBD,sCAsBC"}

package/dist/migration/rebuilds/index.d.ts

@@ -0,0 +1,26 @@
+import { type RebuildTask } from '../rebuild-runner';
+/**
+ * RFC-0008 §8.5 — the registered rebuild tasks.
+ *
+ * Each task wires an existing api-side `run*` helper onto the shared
+ * `RebuildRunner` so the `--dry-run` / progress / SIGINT / structured-logging
+ * conventions are uniform. Tasks carry NO pending/applied state (§8.5): they
+ * never read or append `migrationApplications`.
+ *
+ * `search` and `storage-copy` port the previously top-level `search rebuild` /
+ * `storage copy` commands (their core logic stays in `util/`, unchanged);
+ * `renderer` and `backlink` are skeletons whose `run*` helpers throw a clear
+ * "not implemented" error (no legacy implementation to port).
+ */
+export declare const searchRebuild: RebuildTask;
+/** Options threaded from the CLI into the storage-copy task via the runner. */
+export interface StorageCopyTaskOptions {
+    from: string;
+    to: string;
+}
+export declare function storageCopyRebuild(opts: StorageCopyTaskOptions): RebuildTask;
+export interface RendererTaskOptions {
+    onlyStale: boolean;
+}
+export declare function rendererRebuild(opts: RendererTaskOptions): RebuildTask;
+export declare const backlinkRebuild: RebuildTask;