@crowi/api 2.0.0-alpha.0

package/dist/routes/ts-rest/page.js

@@ -0,0 +1,676 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("@ts-rest/express");
+const api_contract_1 = require("@crowi/api-contract");
+const express_2 = require("express");
+const page_1 = require("../../models/page");
+const ts_rest_helpers_1 = require("../../util/ts-rest-helpers");
+const page_response_1 = require("../../util/page-response");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('crowi:routes:ts-rest:page');
+const VALID_GRANTS = Object.values(api_contract_1.PageGrantEnum);
+const invalidGrantResponse = () => ({
+    status: 400,
+    body: {
+        error: {
+            code: 'INVALID_GRANT',
+            message: 'grant must be one of 1 (public), 2 (restricted), 3 (specified), 4 (owner)',
+        },
+    },
+});
+exports.default = (crowi, _app) => {
+    const s = (0, express_1.initServer)();
+    const router = (0, express_2.Router)();
+    const Page = crowi.model('Page');
+    const User = crowi.model('User');
+    const Watcher = crowi.model('Watcher');
+    // seenUsersCount stays at the raw ID-array length (matching legacy
+    // populatePageData) so inactive users dropped by findUsersByIds' status
+    // filter do not deflate the count. `limit` only caps the returned
+    // `seenUsers` list; the count always reflects the full set.
+    const buildSeenUsersResponse = async (seenUserIds, limit) => {
+        const ids = seenUserIds.filter((id) => id != null);
+        const seenUsersCount = ids.length;
+        if (ids.length === 0) {
+            return { seenUsers: [], seenUsersCount };
+        }
+        const idsToFetch = limit !== undefined ? ids.slice(0, limit) : ids;
+        const populated = (await User.findUsersByIds(idsToFetch));
+        return {
+            seenUsers: populated.map(ts_rest_helpers_1.toUserPublic),
+            seenUsersCount,
+        };
+    };
+    const pageRouter = s.router(api_contract_1.apiContract.page, {
+        /**
+         * GET /api/v2/pages
+         * Get page data by path or page_id
+         * - Supports optional revision_id for historical revisions
+         * - Requires authentication (loginRequired middleware applied at router level)
+         * - Checks page permissions (grant)
+         */
+        getPage: async ({ query, req }) => {
+            const user = req.user;
+            const { path, page_id, revision_id } = query;
+            debug('getPage called with:', { path, page_id, revision_id, userId: user._id });
+            // Validate that at least one of path or page_id is provided
+            if (!path && !page_id) {
+                return {
+                    status: 404,
+                    body: {
+                        error: {
+                            code: 'PAGE_NOT_FOUND',
+                            message: 'Page not found',
+                        },
+                    },
+                };
+            }
+            try {
+                let page = null;
+                // Priority: page_id parameter takes precedence over path
+                // This matches the original controller logic (lines 651-657)
+                if (page_id) {
+                    debug('Finding page by page_id:', page_id);
+                    page = await Page.findPageByIdAndGrantedUser(page_id, user);
+                }
+                else if (path) {
+                    debug('Finding page by path:', path);
+                    page = await Page.findPage(path, user, revision_id || null);
+                }
+                // Ensure page was found
+                if (!page) {
+                    return {
+                        status: 404,
+                        body: {
+                            error: {
+                                code: 'PAGE_NOT_FOUND',
+                                message: 'Page not found',
+                            },
+                        },
+                    };
+                }
+                // Check if page has redirect
+                if (page.redirectTo) {
+                    debug('Page has redirect to:', page.redirectTo);
+                    // For now, return the page with redirectTo field
+                    // Client can handle the redirect
+                    // TODO: Consider if we should follow the redirect automatically
+                }
+                const pageResponse = (0, page_response_1.pageToResponse)(page, { withMeta: true, withRenderedAst: true });
+                // On-the-fly fallback for legacy revisions: one pipeline run
+                // produces both meta + renderedAst, so use the combined helper
+                // to avoid running parse+transform+shiki twice. Stored values
+                // win on merge (anchor ids match page-content's stamper).
+                if (pageResponse.revision && (0, page_response_1.isPopulatedRevision)(page.revision)) {
+                    const { meta, renderedAst } = await (0, page_response_1.computeRevisionRenderArtifactsAsync)(crowi, page.revision.meta, page.revision.renderedAst, page.revision.body, page.revision.rendererVersion, page._id?.toString());
+                    pageResponse.revision.meta = meta;
+                    pageResponse.revision.renderedAst = renderedAst;
+                }
+                // Fire-and-forget recently-viewed touch. Hiccups on the Redis
+                // side mustn't break the page read.
+                crowi.lru.add(user._id.toString(), page._id.toString())?.catch?.((err) => {
+                    debug('lru.add failed (non-fatal):', err);
+                });
+                return {
+                    status: 200,
+                    body: {
+                        page: pageResponse,
+                    },
+                };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error fetching page:', error.message);
+                // Handle specific error types
+                if (error.message === 'Page not found' || error.name === 'Crowi:Page:NotFound') {
+                    return {
+                        status: 404,
+                        body: {
+                            error: {
+                                code: 'PAGE_NOT_FOUND',
+                                message: 'Page not found',
+                            },
+                        },
+                    };
+                }
+                if (error.message === 'Page is not granted for the user') {
+                    return {
+                        status: 403,
+                        body: {
+                            error: {
+                                code: 'PAGE_NOT_GRANTED',
+                                message: 'Page is not granted for the user',
+                            },
+                        },
+                    };
+                }
+                // Generic error fallback
+                debug('Unexpected error:', error);
+                return {
+                    status: 404,
+                    body: {
+                        error: {
+                            code: 'PAGE_NOT_FOUND',
+                            message: 'Page not found',
+                        },
+                    },
+                };
+            }
+        },
+        /**
+         * GET /api/v2/pages/list
+         * List pages by path or user
+         * - Supports pagination with limit and offset
+         * - Returns pages with populated creator and lastUpdateUser
+         */
+        listPages: async ({ query, req }) => {
+            const user = req.user;
+            const { path, user: userParam, limit = 50, offset = 0, include_deleted = false } = query;
+            // Force-enable include_deleted for /trash and /trash/<sub> requests so the
+            // legacy deletedPageListShow semantics are preserved even when the client
+            // omits the query flag (matches old controllers/page.ts behavior).
+            const isTrashPath = !!path && (path === '/trash' || path.startsWith('/trash/'));
+            const includeDeletedPage = include_deleted || isTrashPath;
+            debug('listPages called with:', { path, user: userParam, limit, offset, includeDeletedPage, userId: user._id });
+            try {
+                let pages = [];
+                let portalPage = null;
+                if (userParam) {
+                    // List pages by creator
+                    debug('Finding pages by creator:', userParam);
+                    const targetUser = await crowi.model('User').findById(userParam);
+                    if (!targetUser) {
+                        return {
+                            status: 200,
+                            body: {
+                                pages: [],
+                                pager: {
+                                    prev: null,
+                                    next: null,
+                                    offset: 0,
+                                },
+                                portalPage: null,
+                            },
+                        };
+                    }
+                    // findListByCreator doesn't populate creator/lastUpdateUser, so we need to do it manually
+                    const rawPages = await Page.findListByCreator(targetUser, { limit, offset }, user);
+                    pages = (await Page.populate(rawPages, [{ path: 'creator' }, { path: 'lastUpdateUser' }]));
+                }
+                else if (path && path !== '/') {
+                    // List pages by path. /trash subtrees skip findPortalPage to mirror the
+                    // legacy deletedPageListShow which always rendered with page=null.
+                    debug('Finding pages by path:', path);
+                    debug('Query params:', { limit, offset, path, userParam, includeDeletedPage });
+                    const portalPagePromise = isTrashPath ? Promise.resolve(null) : Page.findPortalPage(path, user);
+                    const listPromise = Page.findListByStartWith(path, user, { limit, offset, includeDeletedPage });
+                    const [rawPortalPage, rawPages] = await Promise.all([portalPagePromise, listPromise]);
+                    // findListByStartWith doesn't populate creator/lastUpdateUser, so we need to do it manually
+                    [portalPage, pages] = (await Promise.all([
+                        rawPortalPage ? Page.populate(rawPortalPage, [{ path: 'creator' }, { path: 'lastUpdateUser' }]) : null,
+                        Page.populate(rawPages, [{ path: 'creator' }, { path: 'lastUpdateUser' }]),
+                    ]));
+                    debug('Found pages:', pages.length);
+                    debug('Found portal page:', !!portalPage);
+                }
+                else {
+                    // List all pages the user can access (including path='/')
+                    debug('Finding all accessible pages', { path });
+                    const conditions = {
+                        redirectTo: null,
+                        $or: (0, page_1.visiblePageStatusOr)(user._id),
+                        grant: { $in: [1, 2] }, // PUBLIC or RESTRICTED
+                    };
+                    // If path='/', also get portal page
+                    if (path === '/') {
+                        [portalPage, pages] = await Promise.all([
+                            Page.findPortalPage(path, user),
+                            Page.find(conditions)
+                                .sort({ updatedAt: -1 })
+                                .skip(offset)
+                                .limit(limit)
+                                .populate({ path: 'revision', populate: { path: 'author' } })
+                                .populate('creator')
+                                .populate('lastUpdateUser')
+                                .exec(),
+                        ]);
+                    }
+                    else {
+                        pages = await Page.find(conditions)
+                            .sort({ updatedAt: -1 })
+                            .skip(offset)
+                            .limit(limit)
+                            .populate({ path: 'revision', populate: { path: 'author' } })
+                            .populate('creator')
+                            .populate('lastUpdateUser')
+                            .exec();
+                    }
+                }
+                // Convert pages to response format
+                const pageResponses = pages.map((page) => (0, page_response_1.pageToResponse)(page));
+                const portalPageResponse = portalPage ? (0, page_response_1.pageToResponse)(portalPage) : null;
+                // Calculate pagination
+                const prev = offset > 0 ? Math.max(0, offset - limit) : null;
+                const next = pages.length === limit ? offset + limit : null;
+                return {
+                    status: 200,
+                    body: {
+                        pages: pageResponses,
+                        pager: {
+                            prev,
+                            next,
+                            offset,
+                        },
+                        portalPage: portalPageResponse,
+                    },
+                };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error listing pages:', error.message);
+                // Return empty list on error
+                return {
+                    status: 200,
+                    body: {
+                        pages: [],
+                        pager: {
+                            prev: null,
+                            next: null,
+                            offset: 0,
+                        },
+                        portalPage: null,
+                    },
+                };
+            }
+        },
+        createPage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { path, body, grant } = requestBody;
+            debug('createPage called with:', { path, grant, userId: user._id });
+            if (grant !== undefined && !VALID_GRANTS.includes(grant)) {
+                return invalidGrantResponse();
+            }
+            try {
+                const existing = await Page.findPage(path, user, null, /* ignoreNotFound */ true);
+                if (existing !== null) {
+                    return {
+                        status: 400,
+                        body: { error: { code: 'PAGE_EXISTS', message: 'Page exists' } },
+                    };
+                }
+                const createOptions = grant !== undefined ? { grant } : {};
+                const created = (await Page.createPage(path, body, user, createOptions));
+                if (!created) {
+                    throw new Error('Failed to create page.');
+                }
+                const populated = await Page.populatePageData(created, null);
+                return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error creating page:', error.message);
+                if (error.message === 'Cannot create non existent user page.') {
+                    return {
+                        status: 400,
+                        body: { error: { code: 'NON_EXISTENT_USER_PAGE', message: error.message } },
+                    };
+                }
+                // Both 'existed path' and 'not granted' map to PAGE_EXISTS: the latter
+                // can occur as a race when a stricter-grant page is created between
+                // findPage and createPage, and we should not leak that distinction.
+                if (error.message === 'Cannot create new page to existed path' || error.message === 'Page is not granted for the user') {
+                    return {
+                        status: 400,
+                        body: { error: { code: 'PAGE_EXISTS', message: 'Page exists' } },
+                    };
+                }
+                return {
+                    status: 400,
+                    body: { error: { code: 'PAGE_CREATE_FAILED', message: error.message || 'Failed to create page' } },
+                };
+            }
+        },
+        updatePage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id, body, revision_id, grant } = requestBody;
+            debug('updatePage called with:', { page_id, revision_id, grant, userId: user._id });
+            if (grant !== undefined && !VALID_GRANTS.includes(grant)) {
+                return invalidGrantResponse();
+            }
+            try {
+                const pageData = (await Page.findPageByIdAndGrantedUser(page_id, user));
+                if (!pageData) {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                if (revision_id && !pageData.isUpdatable(revision_id)) {
+                    return {
+                        status: 409,
+                        body: { error: { code: 'PAGE_REVISION_ERROR', message: 'Revision error.' } },
+                    };
+                }
+                const grantOption = { grant: grant ?? pageData.grant };
+                const updated = (await Page.updatePage(pageData, body, user, grantOption));
+                const populated = await Page.populatePageData(updated, null);
+                return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error updating page:', error.message);
+                if (error.message === 'Page not found' || error.message === 'Page is not granted for the user') {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                return {
+                    status: 400,
+                    body: { error: { code: 'PAGE_UPDATE_FAILED', message: error.message || 'Failed to update page' } },
+                };
+            }
+        },
+        /**
+         * PUT /api/v2/pages/grant
+         *
+         * Grant-only update. Mutates `page.grant` / `grantedUsers` via
+         * Page.updateGrant — no revision is pushed, so changing a page's
+         * visibility never lands a no-op entry in the page history.
+         * Authorization mirrors updatePage (findPageByIdAndGrantedUser).
+         */
+        setPageGrant: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id, grant } = requestBody;
+            debug('setPageGrant called with:', { page_id, grant, userId: user._id });
+            if (!VALID_GRANTS.includes(grant)) {
+                return invalidGrantResponse();
+            }
+            try {
+                const pageData = (await Page.findPageByIdAndGrantedUser(page_id, user));
+                if (!pageData) {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                const updated = (await Page.updateGrant(pageData, grant, user));
+                const populated = await Page.populatePageData(updated, null);
+                return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error updating page grant:', error.message);
+                if (error.message === 'Page not found' || error.message === 'Page is not granted for the user') {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                return {
+                    status: 400,
+                    body: { error: { code: 'PAGE_GRANT_UPDATE_FAILED', message: error.message || 'Failed to update page grant' } },
+                };
+            }
+        },
+        // Idempotent: Page.seen uses addToSet so re-posting from the same user
+        // does not inflate seenUsers / seenUsersCount.
+        seenPage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id } = requestBody;
+            debug('seenPage called with:', { page_id, userId: user._id });
+            const loaded = await (0, ts_rest_helpers_1.loadGrantedPage)(Page, page_id, user);
+            if ('error' in loaded)
+                return loaded.error;
+            const updated = (await loaded.page.seen(user));
+            return { status: 200, body: await buildSeenUsersResponse(updated.seenUsers) };
+        },
+        getSeenUsers: async ({ query, req }) => {
+            const user = req.user;
+            const { page_id, limit } = query;
+            debug('getSeenUsers called with:', { page_id, limit, userId: user._id });
+            const loaded = await (0, ts_rest_helpers_1.loadGrantedPage)(Page, page_id, user);
+            if ('error' in loaded)
+                return loaded.error;
+            return { status: 200, body: await buildSeenUsersResponse(loaded.page.seenUsers, limit) };
+        },
+        /**
+         * POST /api/v2/pages/like
+         * Add the current user to the page's `liker` list.
+         * - Idempotent: liking an already-liked page returns the page unchanged.
+         * - Returns 404 (not 200 with no-op) when the page does not exist or
+         *   the caller has no grant, matching the rest of the page contract
+         *   (cf. updatePage / renamePage). The legacy /_api/likes.add returned
+         *   ApiResponse.success() on errors, but that path was effectively
+         *   unreachable in the legacy UI; see openQuestions in the task plan.
+         */
+        likePage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id } = requestBody;
+            debug('likePage called with:', { page_id, userId: user._id });
+            const loaded = await (0, ts_rest_helpers_1.loadGrantedPage)(Page, page_id, user);
+            if ('error' in loaded)
+                return loaded.error;
+            // pageData.like is a no-op when the user already liked the page. Always
+            // re-populate so the response shape stays stable either way.
+            await loaded.page.like(user);
+            const populated = await Page.populatePageData(loaded.page, null);
+            return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+        },
+        /**
+         * POST /api/v2/pages/unlike
+         * Remove the current user from the page's `liker` list.
+         * - Idempotent: unliking a not-liked page returns the page unchanged.
+         * - Returns 404 for not-found / not-granted, mirroring likePage.
+         */
+        unlikePage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id } = requestBody;
+            debug('unlikePage called with:', { page_id, userId: user._id });
+            const loaded = await (0, ts_rest_helpers_1.loadGrantedPage)(Page, page_id, user);
+            if ('error' in loaded)
+                return loaded.error;
+            // unlike is a no-op when the user had not liked the page. Always
+            // re-populate so the response shape stays stable either way.
+            await loaded.page.unlike(user);
+            const populated = await Page.populatePageData(loaded.page, null);
+            return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+        },
+        /**
+         * Resolution order matches legacy controllers/page.ts api.watchStatus:
+         *   1. If a Watcher record exists for (user, page), use watcher.isWatching().
+         *   2. Otherwise derive a default from page.getNotificationTargetUsers()
+         *      (creator + comment authors + revision authors). The user is
+         *      "watching by default" iff their id appears in that list.
+         */
+        getWatchStatus: async ({ query, req }) => {
+            const user = req.user;
+            const { page_id } = query;
+            debug('getWatchStatus called with:', { page_id, userId: user._id });
+            const loaded = await (0, ts_rest_helpers_1.loadGrantedPage)(Page, page_id, user);
+            if ('error' in loaded)
+                return loaded.error;
+            const watcher = await Watcher.findByUserIdAndTargetId(user._id, loaded.page._id);
+            if (watcher) {
+                return { status: 200, body: { watching: watcher.isWatching() } };
+            }
+            // Default: include user when they appear in the page's notification
+            // target users (creator + comment authors + revision authors).
+            const targetUsers = await loaded.page.getNotificationTargetUsers();
+            const userIdStr = user._id.toString();
+            const watching = targetUsers.some((id) => id.toString() === userIdStr);
+            return { status: 200, body: { watching } };
+        },
+        /**
+         * - watching=true  -> status=WATCH
+         * - watching=false -> status=IGNORE
+         *
+         * This 2-state API cannot remove the Watcher (i.e. revert to the
+         * default-derived behaviour). If a 3-state UI is needed later, the
+         * contract will be extended.
+         */
+        setWatchStatus: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id, watching } = requestBody;
+            debug('setWatchStatus called with:', { page_id, watching, userId: user._id });
+            const loaded = await (0, ts_rest_helpers_1.loadGrantedPage)(Page, page_id, user);
+            if ('error' in loaded)
+                return loaded.error;
+            const status = watching ? Watcher.STATUS_WATCH : Watcher.STATUS_IGNORE;
+            await Watcher.watchByPageId(user._id, loaded.page._id, status);
+            return { status: 200, body: { watching } };
+        },
+        deletePage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id, revision_id, completely } = requestBody;
+            debug('deletePage called with:', { page_id, revision_id, completely, userId: user._id });
+            try {
+                const pageData = (await Page.findPageByIdAndGrantedUser(page_id, user));
+                if (!pageData) {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                // Hard delete bypasses revision check (matches old controllers/page.ts api.remove).
+                if (completely === true) {
+                    await Page.completelyDeletePage(pageData, user);
+                    // After completelyDeletePage the document is gone from Mongo; we still
+                    // return the in-memory pageData so the client knows what was deleted.
+                    return { status: 200, body: { page: (0, page_response_1.pageToResponse)(pageData) } };
+                }
+                if (revision_id && !pageData.isUpdatable(revision_id)) {
+                    return {
+                        status: 409,
+                        body: { error: { code: 'PAGE_REVISION_ERROR', message: 'Revision error.' } },
+                    };
+                }
+                // Page.deletePage mutates pageData (status -> deleted, path -> /trash/<path>)
+                // and internally calls Page.rename which returns the *redirect* page (a quirk
+                // of the old model). We re-populate the mutated pageData so the response
+                // reflects the soft-deleted page itself, which is what callers actually want.
+                await Page.deletePage(pageData, user);
+                const populated = await Page.populatePageData(pageData, null);
+                return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error deleting page:', error.message);
+                if (error.message === 'Page not found' || error.message === 'Page is not granted for the user') {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                return {
+                    status: 400,
+                    body: { error: { code: 'PAGE_DELETE_FAILED', message: error.message || 'Failed to delete page' } },
+                };
+            }
+        },
+        revertDeletedPage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id } = requestBody;
+            debug('revertDeletedPage called with:', { page_id, userId: user._id });
+            try {
+                const pageData = (await Page.findPageByIdAndGrantedUser(page_id, user));
+                if (!pageData) {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                // Page.revertDeletedPage mutates pageData (path -> non-trash, status -> published)
+                // and removes the redirect stub at the original /trash path. The function returns
+                // pageData itself, but we re-populate to ensure creator/lastUpdateUser/revision are
+                // resolved for the response.
+                await Page.revertDeletedPage(pageData, user);
+                const populated = await Page.populatePageData(pageData, null);
+                return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error reverting deleted page:', error.message);
+                if (error.message === 'Page not found' || error.message === 'Page is not granted for the user') {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                return {
+                    status: 400,
+                    body: { error: { code: 'PAGE_REVERT_FAILED', message: error.message || 'Failed to revert deleted page' } },
+                };
+            }
+        },
+        renamePage: async ({ body: requestBody, req }) => {
+            const user = req.user;
+            const { page_id, new_path, revision_id, create_redirect } = requestBody;
+            debug('renamePage called with:', { page_id, new_path, revision_id, create_redirect, userId: user._id });
+            // Normalize the destination path and validate the name first so we can
+            // reject obviously bad inputs without touching the DB.
+            const newPagePath = Page.normalizePath(new_path);
+            const newPageIsPortal = newPagePath.endsWith('/');
+            if (!Page.isCreatableName(newPagePath)) {
+                return {
+                    status: 400,
+                    body: {
+                        error: {
+                            code: 'PAGE_INVALID_NAME',
+                            message: `Cannot rename to this page name (${newPagePath})`,
+                        },
+                    },
+                };
+            }
+            try {
+                // Authorization: same pattern as updatePage. Hide existence from
+                // callers without grant by returning 404.
+                const pageData = (await Page.findPageByIdAndGrantedUser(page_id, user));
+                if (!pageData) {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                if (revision_id && !pageData.isUpdatable(revision_id)) {
+                    return {
+                        status: 409,
+                        body: { error: { code: 'PAGE_REVISION_ERROR', message: 'Revision error.' } },
+                    };
+                }
+                // Detect collision at the destination path. If the existing page is a
+                // redirect that the user is allowed to remove, unlink it first;
+                // otherwise refuse the rename. This mirrors controllers/page.ts.
+                const existingAtNewPath = await Page.findOne({ path: newPagePath });
+                if (existingAtNewPath) {
+                    if (existingAtNewPath.isUnlinkable(user)) {
+                        try {
+                            await existingAtNewPath.unlink(user);
+                        }
+                        catch (err) {
+                            const error = err;
+                            return {
+                                status: 400,
+                                body: {
+                                    error: {
+                                        code: 'PAGE_RENAME_FAILED',
+                                        message: error.message || 'Failed to unlink redirect page at destination',
+                                    },
+                                },
+                            };
+                        }
+                    }
+                    else {
+                        return {
+                            status: 400,
+                            body: {
+                                error: {
+                                    code: 'PAGE_EXISTS',
+                                    message: `Cannot rename to this page name (${newPagePath}). Page exists.`,
+                                },
+                            },
+                        };
+                    }
+                }
+                // Old controller: `(!newPageIsPortal && createRedirect) || 0` — portal
+                // paths (ending in '/') never get a redirect page even if requested.
+                const options = {
+                    createRedirectPage: !newPageIsPortal && Boolean(create_redirect),
+                };
+                await Page.rename(pageData, newPagePath, user, options);
+                const populated = await Page.populatePageData(pageData, null);
+                return { status: 200, body: { page: (0, page_response_1.pageToResponse)(populated) } };
+            }
+            catch (err) {
+                const error = err;
+                debug('Error renaming page:', error.message);
+                if (error.message === 'Page not found' || error.message === 'Page is not granted for the user') {
+                    return ts_rest_helpers_1.pageNotFoundResponse;
+                }
+                return {
+                    status: 400,
+                    body: { error: { code: 'PAGE_RENAME_FAILED', message: error.message || 'Failed to rename page' } },
+                };
+            }
+        },
+    });
+    (0, express_1.createExpressEndpoints)(api_contract_1.apiContract.page, pageRouter, router);
+    return router;
+};
+//# sourceMappingURL=page.js.map