domma-cms 1.8.10 → 1.8.12

package/server/services/wpImport/plan.js

@@ -25,6 +25,18 @@
  * beside the export (./widgets.js), become one block per widget area, and a
  * footer area's block joins the footer (summary.widgets).
  *
+ * The home page (./front.js, plan.home): the page WordPress showed at its home
+ * address becomes this site's home page (options.home, on by default when one
+ * is found); the page there now moves to /previous-home as a draft - once, on
+ * the first run that does it (mapping `home`), never again without asking: when
+ * an earlier import set the home page and this export's front page is another
+ * page, plan.home.question asks (options.homeReplace, no default - the run is
+ * refused until it is answered). Yes moves the home page aside the same way;
+ * No imports the page at its own address. A suggested posts
+ * page, once confirmed (options.postsPage), is not made: its old address leads
+ * to the Blog. With no front page, the latest posts can be the home page
+ * (options.latestPosts, a page holding the Blog's [blog-list]).
+ *
  * @module services/wpImport/plan
  */
 import {detectBuilder, findShortcodes} from './convert.js';
@@ -34,6 +46,7 @@ import {readWooProducts, shopProductInput, wooPageRole} from './woo.js';
 import {customFields, customOldPath, customTypesOf, mediaContext, rewriteSlugOf, typeLabel} from './custom.js';
 import {planPeople} from './people.js';
 import {planWidgets} from './widgets.js';
+import {detectFrontPage, suggestPostsPage} from './front.js';
 
 /** Addresses under the Shop's that are its own pages, never a product's. */
 const SHOP_RESERVED = ['cart', 'checkout', 'basket', 'account', 'order'];
@@ -219,6 +232,12 @@ export function isoDate(gmt, local) {
  * @param {object} [options.people] - what the person running it may do with users (never from a request)
  * @param {object|null} [options.wie] - the widgets file, from readWie() (./widgets.js)
  * @param {Object<string,false>} [options.footer] - per widget area: false = not placed in the footer
+ * @param {boolean} [options.home=true] - the WordPress front page becomes this site's home page
+ * @param {number} [options.postsPage] - the suggested posts page, confirmed (its WordPress id)
+ * @param {boolean} [options.latestPosts=false] - no front page: the latest posts on the home page
+ * @param {boolean|null} [options.homeReplace=null] - the answer to plan.home.question: make this export's
+ *   front page the home page instead of the one an earlier import set (null: not answered)
+ * @param {string|null} [site.homeTitle] - the title of the page at / now (null: none)
  * @returns {object}
  */
 export function planImport(wxr, site, mapping = {}, options = {}) {
@@ -226,6 +245,7 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         posts: site.blog?.available ? 'blog' : 'pages',
         media: 'download', comments: true, menus: true, redirects: true, drafts: true, products: true, choices: {}, zipPaths: null,
         types: {}, listPages: {}, users: {}, userRole: '', invite: false, footer: {}, wie: null,
+        home: true, postsPage: 0, latestPosts: false, homeReplace: null,
         ...options
     };
     opt.types ||= {};
@@ -247,7 +267,9 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     const notes = [];
     const byId = new Map(wxr.items.map(it => [it.id, it]));
 
-    const takenPaths = new Set(site.pagePaths);
+    // An address this site already redirects (and not by this import) would hide a page made there: taken too.
+    const ownRedirectFroms = new Set(Object.values(mapping.redirects || {}).map(r => r?.from));
+    const takenPaths = new Set([...site.pagePaths, ...[...(site.redirectFroms || [])].filter(f => typeof f === 'string' && !f.includes('*') && !ownRedirectFroms.has(f))]);
     const takenMedia = new Set(site.mediaNames);
     const takenMenus = new Set(site.menuSlugs);
     const takenSlugs = new Set(site.blog?.postSlugs || []);
@@ -294,6 +316,62 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     // Parents before children, so a child's address can follow its parent's.
     const depthOf = (it, seen = new Set()) => (it.parent && byId.has(it.parent) && !seen.has(it.id) ? 1 + depthOf(byId.get(it.parent), seen.add(it.id)) : 0);
     const orderedPages = [...pages].sort((a, b) => depthOf(a) - depthOf(b) || a.order - b.order || a.id - b.id);
+    // ---- The home page: WordPress's front page, its posts page (./front.js) ----
+    // `home` in the mapping: an earlier run set this site's home page - it is not moved again without asking.
+    // An import of another WordPress site that set it counts too (site.homeSetBy): the latest one is the home page.
+    const ownHome = mapped.home?.kind === 'home' ? mapped.home : null;
+    const otherHome = site.homeSetBy?.kind === 'home' ? site.homeSetBy : null;
+    const homeRec = otherHome && (!ownHome || String(otherHome.at || '') > String(ownHome.at || '')) ? otherHome : ownHome;
+    const leftAsIs = homeRec?.source
+        ? `An earlier import (of ${homeRec.source}) set this site's home page - it is left as it is.`
+        : 'This site\'s home page was changed here since the last import - it is left as it is.';
+    const {page: front, matches: frontMatches} = detectFrontPage(wxr);
+    const suggested = opt.posts !== 'skip' ? suggestPostsPage(wxr, {front, blogBase}) : null;
+    // Imported before as a page that is still here: the person's page now - never hidden behind a redirect.
+    const suggestedAt = suggested && mapped[`page:${suggested.id}`]?.path;
+    const postsCandidate = suggested && !(suggestedAt && site.pagePaths.has(suggestedAt)) ? suggested : null;
+    const postsPageId = postsCandidate && Number(opt.postsPage) === postsCandidate.id ? postsCandidate.id : 0;
+    const latestOffered = !front && !frontMatches && opt.posts === 'blog' && Boolean(site.shortcodes?.has('blog-list'));
+    let homeMove = null;
+    let homeChanged = '';
+    /**
+     * Something of this run's takes "/": the page there now moves to /previous-home (-2…), never deleted.
+     * `replace`: the person said Yes to the question - even a page an earlier run of this import put there moves.
+     */
+    const claimHome = (replace = false) => {
+        if (homeMove) return;
+        if (site.pagePaths.has('/') && (replace || !ownPaths.has('/'))) {
+            const to = freePath('/previous-home', takenPaths);
+            takenPaths.add(to);
+            takenPaths.delete('/');
+            homeMove = {from: '/', to};
+        }
+    };
+    // ---- The question: an earlier import set the home page, and this export's front page is another page ----
+    const frontKey = front ? `page:${front.id}` : '';
+    const frontWas = front ? mapped[frontKey] : null;
+    // Deleted here since an earlier run made it: not imported, or ("Import again") brought back at its old address -
+    // either way it does not take "/", so there is nothing to ask.
+    const frontGone = Boolean(frontWas?.path && !site.pagePaths.has(frontWas.path));
+    // The same page this import made the home page (a re-run), or already at "/" anyway: nothing to ask.
+    const sameHome = Boolean(homeRec && !homeRec.source && homeRec.how !== 'latest' && Number(homeRec.wpId) === front?.id);
+    const frontIsHome = frontWas?.path === '/' && site.pagePaths.has('/');
+    const askHome = Boolean(front && opt.home && choices[frontKey] !== 'skip' && !frontGone && homeRec && !sameHome && !frontIsHome && site.pagePaths.has('/'));
+    const homeAnswer = askHome && typeof opt.homeReplace === 'boolean' ? opt.homeReplace : null;
+    const replaceHome = homeAnswer === true;
+    // Yes: what is at "/" moves aside before any page is planned, so a page of this import's that is there now
+    // is planned at its new address (planDocument), not over the new home page.
+    if (replaceHome) claimHome(true);
+    const homeAddress = (it) => {
+        const p = oldPathOf(it.link, wxr.site);
+        return p !== null && relative(p, base) === '/';
+    };
+    /** WordPress's own address for a page by its slugs (/about/team) - the front page answered there too. */
+    const slugAddress = (it) => {
+        const segs = [];
+        for (let c = it, n = 0; c && n < 10; c = c.parent ? byId.get(c.parent) : null, n++) segs.unshift(slugify(c.slug));
+        return segs.every(Boolean) ? `${base}/${segs.join('/')}` : '';
+    };
     const WOO_PAGE = {
         cart: {to: '/cart', what: 'cart'}, checkout: {to: '/cart', what: 'checkout'},
         account: {to: '/account', what: 'account page'}, shop: {to: '', what: 'shop page'}
@@ -309,8 +387,30 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
             if (oldPath) extraRedirects.push({from: oldPath, to, key});
             continue;
         }
+        if (postsPageId === it.id) {
+            if (opt.posts === 'blog') {
+                // The Blog lists the posts itself: no empty page, and the old address leads there.
+                push({...docRow(it, key, 'page', oldPath), status: 'published', action: 'skip', postsPage: true, target: blogBase,
+                    reason: `WordPress's posts page - the Blog lists the posts at ${blogBase}, so no empty page is made${oldPath ? ' and the old address leads there' : ''}.`});
+                if (oldPath) extraRedirects.push({from: oldPath, to: blogBase, key: `${key}/posts`});
+                continue;
+            }
+            // Posts as pages: it becomes their index, where they are put.
+            const r = planDocument({it, key, kind: 'page', wanted: pagesBase, oldPath, statusMap: PAGE_STATUS});
+            r.postsIndex = true;
+            if (r.action === 'create' && !r.reason) r.reason = `WordPress's posts page - it lists the posts imported as pages under ${pagesBase}.`;
+            if (r.target) pageTarget.set(it.id, r.target);
+            continue;
+        }
+        if (front?.id === it.id && opt.home && choices[key] !== 'skip') {
+            const r = planFront(it, key, oldPath);
+            if (r.target) pageTarget.set(it.id, r.target);
+            continue;
+        }
         let wanted = oldPath ? cleanPath(relative(oldPath, base)) : '';
         if (!wanted || wanted === '/' && oldPath !== null && relative(oldPath, base) !== '/') wanted = '';
+        // Only the one front page takes "/" (and only when chosen): another page at the home address keeps its slug.
+        if (wanted === '/' && homeAddress(it)) wanted = '';
         if (!wanted) {
             const parentPath = it.parent && pageTarget.get(it.parent);
             const slug = slugify(it.slug) || slugify(it.title) || `page-${it.id}`;
@@ -320,6 +420,25 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         if (row.target) pageTarget.set(it.id, row.target);
     }
 
+    // ---- No front page: the latest posts on the home page, when chosen ----
+    if (latestOffered && opt.latestPosts) {
+        const key = 'home:latest';
+        const was = mapped[key];
+        let wanted = '/';
+        if (!was?.path && choices[key] !== 'skip') {
+            if (!homeRec) claimHome();
+            else if (takenPaths.has('/')) { wanted = ''; homeChanged = leftAsIs; }
+        }
+        if (wanted) {
+            const r = planDocument({it: {id: 0, title: wxr.site.title || 'Latest posts', link: '', status: 'publish', content: '', meta: {}, terms: [], password: ''},
+                key, kind: 'page', wanted, oldPath: null, statusMap: PAGE_STATUS});
+            r.homeLatest = true;
+            r.wpId = 0;
+            r.title = 'Home page: the latest posts';
+            if (r.action === 'create' && !r.reason) r.reason = 'Shows the latest Blog posts, as WordPress did on its home page.';
+        }
+    }
+
     // ---- Posts ----
     const posts = wxr.items.filter(i => i.type === 'post');
     for (const it of posts) {
@@ -552,6 +671,8 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     const query = {p: {}, page_id: {}, attachment_id: {}};
     const live = (r) => r.target && r.action !== 'skip';
     for (const r of items) {
+        // A confirmed posts page is not made: ?page_id= for it leads to the Blog.
+        if (r.postsPage) { query.page_id[r.wpId] = r.target; query.p[r.wpId] = r.target; continue; }
         // An entry in a collection has no address of its own: its old one leads to the type's list page.
         if (r.kind === 'custom' && r.as === 'collection' && r.action !== 'skip') {
             if (r.listAt) query.p[r.wpId] = r.listAt;
@@ -662,6 +783,7 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     const productRows = items.filter(r => r.kind === 'product');
     const people = planPeople(wxr, items, site.users || [], mapping, opt, opt.people || {});
     const shortcodeCount = items.reduce((n, r) => n + (r.shortcodes?.length || 0), 0);
+    const home = homeSummary();
 
     const summary = {
         counts,
@@ -696,11 +818,71 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         query,
         mediaByRel,
         people,
+        home,
         notes: [...new Set(notes)],
         summary
     };
 
     // ---- helpers sharing the plan's state ----
+    /**
+     * WordPress's front page, chosen as the home page. The first run that does it moves the page at "/"
+     * away (claimHome); a re-run updates it where it is, and if the home page was changed here by hand
+     * since, leaves the home page alone and says so.
+     */
+    function planFront(it, key, oldPath) {
+        const was = mapped[key];
+        const here = was?.path && site.pagePaths.has(was.path) ? was.path : '';
+        const slugPath = slugAddress(it);
+        let row;
+        if (homeRec && !replaceHome) {
+            // Set by an earlier run: never moved again (unless the person said Yes to the question).
+            if (here && here !== '/') homeChanged = `This site's home page was changed here since the last import - "${it.title || 'the home page'}" stays at ${here}.`;
+            let wanted = '/';
+            if (!here && takenPaths.has('/')) {
+                wanted = `/${slugify(it.slug) || slugify(it.title) || 'home'}`;
+                homeChanged = leftAsIs;
+            }
+            row = planDocument({it, key, kind: 'page', wanted, oldPath, statusMap: PAGE_STATUS});
+            // Asked: No keeps this site's home page and the page arrives at its own address; unanswered, the card asks.
+            if (askHome) homeChanged = homeAnswer === false ? `You chose to keep this site's home page - "${it.title || 'the page'}" is imported${row.target ? ` at ${row.target}` : ''}.` : '';
+        } else {
+            // Deleted here since an earlier run made it (not as the home page): that is the person's call, as for any page.
+            if (!was?.path || here) claimHome(replaceHome);
+            row = planDocument({it, key, kind: 'page', wanted: '/', oldPath, statusMap: PAGE_STATUS});
+            // Imported before at another address (not as the home page then): it moves to "/".
+            if (here && here !== '/' && row.action !== 'skip') {
+                row.moveFrom = here;
+                row.target = '/';
+                takenPaths.add('/');
+                extraRedirects.push({from: here, to: '/', key: `${key}/moved`});
+            }
+        }
+        row.front = true;
+        if (row.target === '/' && slugPath && slugPath !== '/') extraRedirects.push({from: slugPath, to: '/', key: `${key}/slug`});
+        return row;
+    }
+    function homeSummary() {
+        const frontRow = front ? items.find(r => r.key === `page:${front.id}`) : null;
+        const latestRow = items.find(r => r.key === 'home:latest');
+        const postsRow = postsCandidate ? items.find(r => r.key === `page:${postsCandidate.id}`) : null;
+        return {
+            how: front ? 'page' : frontMatches > 1 ? 'unclear' : 'latest',
+            matches: frontMatches,
+            on: opt.home !== false,
+            page: front ? {wpId: front.id, title: front.title || '(untitled)', oldUrl: front.link, target: frontRow?.target || '', action: frontRow?.action || 'skip', isHome: frontRow?.target === '/' && frontRow.action !== 'skip'} : null,
+            now: site.pagePaths.has('/') ? {title: site.homeTitle ?? ''} : null,
+            move: homeMove,
+            // An earlier import set the home page and this front page is another: asked, never assumed.
+            question: askHome ? {title: front.title || '(untitled)', current: site.homeTitle ?? '', answer: homeAnswer} : null,
+            done: homeRec ? {how: homeRec.how || 'page', previous: homeRec.previous || '', source: homeRec.source || ''} : null,
+            changed: homeChanged,
+            latest: {offered: latestOffered, on: Boolean(latestOffered && opt.latestPosts), target: latestRow?.target || '', action: latestRow?.action || ''},
+            postsPage: postsCandidate ? {
+                wpId: postsCandidate.id, title: postsCandidate.title || '(untitled)', oldUrl: postsCandidate.link,
+                confirmed: Boolean(postsPageId), to: opt.posts === 'blog' ? blogBase : (postsRow?.postsIndex ? postsRow.target : pagesBase)
+            } : null
+        };
+    }
     function docRow(it, key, kind, oldPath) {
         return {
             key, kind, wpId: it.id, title: it.title || `(untitled ${kind} ${it.id})`, oldUrl: it.link, oldPath,
@@ -718,6 +900,11 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         if (it.password) row.status = 'draft';
         const was = mapped[key];
         const why = excluded(it);
+        // The home page until now, made by an earlier run of this import: Yes to the question moves it aside as a draft.
+        if (replaceHome && homeMove && was?.path === '/' && key !== frontKey && site.pagePaths.has('/')) {
+            return push({...row, action: 'keep', target: homeMove.to, movedAside: true,
+                reason: `This site's home page until now - it moves to ${homeMove.to} as a draft, nothing is deleted.`});
+        }
         if (choices[key] === 'skip') return push({...row, action: 'skip', reason: 'You chose to skip it.'});
         if (why) return push({...row, action: 'skip', reason: why});
         if (was?.path) {