domma-cms 1.8.1 → 1.8.3

package/server/services/wpImport/index.js

@@ -19,6 +19,12 @@
  * (feature-detected from the collections, see blogTarget()); otherwise they
  * become pages under /blog, or are skipped - the preview says which.
  *
+ * WooCommerce products go to the Shop when a Tool owning `shop-products` is
+ * switched on and running (shopTarget()), written through the Shop's own save
+ * (its extension registry's services.saveProduct), so a product imported here
+ * is one the Shop's editor would have made. Without one they are listed as
+ * skipped.
+ *
  * The one request hook here answers WordPress's query addresses (/?p=12,
  * /?page_id=7, /?attachment_id=3) from the mapping; path redirects go into
  * SEO's redirect store.
@@ -33,13 +39,14 @@ import {readWxr} from './wxr.js';
 import {openZip, ZipError} from './zip.js';
 import {freeName, isoDate, mediaName, menuItems, originalUploadsPath, planImport, seoFields, uploadsPath} from './plan.js';
 import {convertContent} from './convert.js';
+import {currencyDecimals, mergeForUpdate, productFingerprintParts, readWooProducts, shopProductInput} from './woo.js';
 import {fetchMedia, testHostsAllowed} from './fetch.js';
 import {
     addHistory, clearRunning, createStaging, dropStaging, fingerprint, markRunning, recordFailedRun, recoverInterrupted, followRename, forgetMapCache, mappingFor, newId, queryTarget, saveMapping,
     stagingMeta, stagingPath, updateStagingMeta
 } from './store.js';
 import {createPage, getPage, listMedia, listPages, resolveExistingFilePath, saveMedia, updatePage} from '../content.js';
-import {createEntry, getCollection, listEntries, updateEntry} from '../collections.js';
+import {createEntry, getCollection, getEntry, listEntries, updateEntry} from '../collections.js';
 import {getPluginStates} from '../plugins.js';
 import {createMenu, getMenu, listMenus, updateMenu} from '../menus.js';
 import {listUsers} from '../users.js';
@@ -116,6 +123,52 @@ export async function blogTarget() {
     return out;
 }
 
+// ---- The Shop, if there is one -------------------------------------------
+
+const SHOP_PRODUCTS = 'shop-products';
+/** The Shop's extension door (shopping-cart lib/extensions.js) - reached without importing a plugin file. */
+const SHOP_REGISTRY = Symbol.for('domma.shopping-cart');
+const SHOP_FIELDS = ['name', 'slug', 'price', 'compareAt', 'sku', 'category', 'status', 'stock'];
+
+/** The Shop's own product save, when a Shop is running in this process. */
+const shopSave = () => {
+    const reg = globalThis[SHOP_REGISTRY];
+    return reg?.version >= 1 && typeof reg.services?.saveProduct === 'function' ? reg.services.saveProduct : null;
+};
+
+/**
+ * Whether products can go to a Shop: a switched-on Tool ships the
+ * `shop-products` collection (feature-detected, never by name), the site's
+ * collection has the fields a product needs, and the Shop is running - its
+ * own save (services.saveProduct) is what writes them. The storefront's
+ * address and the currency are the owning Tool's settings.
+ */
+export async function shopTarget() {
+    const out = {available: false, basePath: '/shop', owner: '', currency: 'GBP', decimals: 2, reason: ''};
+    try {
+        const owners = await ownersOf(SHOP_PRODUCTS);
+        if (!owners.length) { out.reason = 'Switch on the Shop to bring these in.'; return out; }
+        if (!shopSave()) { out.reason = 'The Shop is switched on but has not started yet - restart the site, then preview again.'; return out; }
+        const schema = await getCollection(SHOP_PRODUCTS).catch(() => null);
+        if (!hasFields(schema, SHOP_FIELDS)) { out.reason = 'The Shop\'s products on this site are not in the shape the importer writes, so products are left out.'; return out; }
+        out.available = true;
+        out.owner = owners[0];
+        // The Shop's own reading of its settings when it offers one: its save prices in ITS currency and
+        // it answers at ITS cleaned path, so a hand-edited setting cannot put the two out of step.
+        const live = globalThis[SHOP_REGISTRY]?.services?.liveSettings;
+        const st = (typeof live === 'function' ? await live().catch(() => null) : null) || getPluginStates()?.[out.owner]?.settings || {};
+        if (typeof st.shopPath === 'string' && /^\/?[a-z0-9/_-]*$/i.test(st.shopPath.trim())) {
+            out.basePath = `/${st.shopPath.trim().toLowerCase().replace(/^\/+|\/+$/g, '')}`.replace(/\/{2,}/g, '/');
+        }
+        const cur = String(st.currency || 'GBP').trim().toUpperCase();
+        out.currency = /^[A-Z]{3}$/.test(cur) ? cur : 'GBP';
+        out.decimals = currencyDecimals(out.currency);
+    } catch { /* no Shop */ }
+    return out;
+}
+
+export const productFingerprint = (d) => fingerprint(productFingerprintParts(d));
+
 const entriesOf = (r) => (Array.isArray(r) ? r : Array.isArray(r?.entries) ? r.entries : []);
 
 // ---- What the site has now ----------------------------------------------
@@ -162,9 +215,19 @@ export async function siteState(mapping = {}) {
             if (e.data?.slug) blog.categories.set(e.data.slug, e.id);
         }
     }
+    const shop = await shopTarget();
+    shop.products = new Map();
+    shop.productSlugs = new Set();
+    if (shop.available) {
+        for (const e of entriesOf(await listEntries(SHOP_PRODUCTS, {limit: 100000}).catch(() => []))) {
+            const d = e.data || {};
+            shop.products.set(e.id, {slug: d.slug, hash: productFingerprint(d)});
+            if (d.slug) shop.productSlugs.add(d.slug);
+        }
+    }
     const seo = seoEngine();
     return {
-        pagePaths, pageHashes,
+        pagePaths, pageHashes, shop,
         mediaNames: new Set(media.map(m => String(m.name).toLowerCase())),
         menuSlugs: new Set(menus.map(m => m.slug)),
         menuHashes,
@@ -272,6 +335,7 @@ export function cleanOptions(o = {}) {
         menus: o.menus !== false,
         redirects: o.redirects !== false,
         drafts: o.drafts !== false,
+        products: o.products !== false,
         choices
     };
 }
@@ -416,7 +480,7 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     for (const [aid, m] of mediaById) mapping.query.attachment_id[aid] = m.url;
 
     // Address lookups for content and menus.
-    const targetOf = new Map(plan.items.filter(r => (r.kind === 'page' || r.kind === 'post') && r.target && r.action !== 'skip').map(r => [r.wpId, r.target]));
+    const targetOf = new Map(plan.items.filter(r => (r.kind === 'page' || r.kind === 'post' || r.kind === 'product') && r.target && r.action !== 'skip').map(r => [r.wpId, r.target]));
     const oldPathTarget = new Map(plan.items.filter(r => r.oldPath && r.target && r.action !== 'skip').map(r => [r.oldPath, r.target]));
     const {oldPathOf, basePathOf} = await import('./plan.js');
     const mediaFor = (url) => {
@@ -543,9 +607,58 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     }
 
     await checkpoint(true);
-    // ---- 5. Menus ----
+    // ---- 5. Products (to the Shop) ----
+    const productRows = plan.items.filter(x => x.kind === 'product');
+    if (productRows.length) {
+        job.phase = 'Products';
+        const shop = productRows.some(works) ? await shopTarget() : null;
+        const save = shopSave();
+        const woo = new Map(readWooProducts(wxr).map(p => [p.id, p]));
+        const shopAt = (slug) => `${plan.shopBase === '/' ? '' : plan.shopBase}/${slug}`;
+        for (const r of productRows) {
+            const p = woo.get(r.wpId);
+            if (!works(r)) {
+                if (r.action === 'keep') { mapping.items[r.key] = oldMapping.items[r.key]; recordProductQuery(mapping, r.target, p); }
+                set(r.key, {result: r.action === 'keep' ? 'kept' : 'skipped', target: r.target});
+                continue;
+            }
+            try {
+                if (!shop?.available || !save) throw new Error(shop?.reason || 'The Shop is not running.');
+                const conv = convert(p.item);
+                const {input} = shopProductInput(p, {
+                    slug: r.slug, description: conv.body, mediaUrl: (aid) => mediaById.get(aid)?.url || null,
+                    decimals: shop.decimals, published: r.status === 'active', now: plan.options.now
+                });
+                let res;
+                if (r.action === 'update' && r.entryId) {
+                    const now = await getEntry(SHOP_PRODUCTS, r.entryId);
+                    if (!now) throw new Error('It was deleted from the Shop while the import ran.');
+                    res = await save(mergeForUpdate(now.data, input), {id: r.entryId});
+                } else {
+                    res = await save(input);
+                }
+                if (res?.notFound) throw new Error('It was deleted from the Shop while the import ran.');
+                if (res?.errors) throw new Error(Object.values(res.errors)[0] || 'The Shop refused it.');
+                const entry = res?.entry;
+                if (!entry?.id) throw new Error('The Shop did not save it.');
+                const target = shopAt(entry.data.slug);
+                mapping.items[r.key] = {kind: 'product', entryId: entry.id, slug: entry.data.slug, hash: productFingerprint(entry.data), at: new Date().toISOString()};
+                recordProductQuery(mapping, target, p);
+                // The Shop keeps product addresses unique itself: follow it if it chose another.
+                if (target !== r.target) for (const x of plan.redirects) if (x.key === r.key || x.key === `${r.key}/product`) x.to = target;
+                set(r.key, {result: r.action === 'update' ? 'updated' : 'created', target, entryId: entry.id, notes: conv.notes, format: conv.format});
+            } catch (err) {
+                set(r.key, {result: 'failed', error: err.message || String(err)});
+            }
+            await step(r.title);
+        }
+    }
+
+    await checkpoint(true);
+    // ---- 6. Menus ----
     job.phase = 'Menus';
     const categoryAddress = new Map(plan.items.filter(r => r.kind === 'category' && r.action !== 'skip').map(r => [r.slug, r.target]));
+    for (const r of plan.redirects) if (r.key.startsWith('product_cat:')) categoryAddress.set(r.key, r.to);
     for (const r of plan.items.filter(x => x.kind === 'menu')) {
         if (!works(r)) {
             if (r.action === 'keep') mapping.items[r.key] = oldMapping.items[r.key];
@@ -569,7 +682,7 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     }
 
     await checkpoint(true);
-    // ---- 6. Redirects ----
+    // ---- 7. Redirects ----
     job.phase = 'Redirects';
     const seo = seoEngine();
     const redirectResults = [];
@@ -592,7 +705,7 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
         await step(r.from);
     }
 
-    // ---- 7. Save the mapping, the report, the history ----
+    // ---- 8. Save the mapping, the report, the history ----
     job.phase = 'Finishing';
     await saveMapping(plan.source, mapping);
     forgetMapCache();
@@ -606,6 +719,13 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     log.info?.(`[wordpress-import] ${plan.site.title || plan.source}: ${JSON.stringify(report.run.summary)}`);
 }
 
+/** ?p= for a product, and for each of its variations, leads to the product. */
+function recordProductQuery(mapping, target, p) {
+    if (!target || !p) return;
+    mapping.query.p[p.id] = target;
+    for (const v of p.variations) mapping.query.p[v.id] = target;
+}
+
 function recordQuery(mapping, r) {
     if (!r.target) return;
     if (r.kind === 'page') { mapping.query.page_id[r.wpId] = r.target; mapping.query.p[r.wpId] = r.target; }
@@ -754,7 +874,8 @@ function buildReport({job, plan, results, redirectResults, meta, user, started,
         return {
             key: r.key, kind: r.kind, title: r.title, wpId: r.wpId, oldUrl: r.oldUrl || '', target: res.target || r.target || '',
             planned: r.action, result: res.result, reason: res.error || r.reason || '',
-            shortcodes: r.shortcodes || [], builder: r.builder || '', notes: res.notes || [], format: res.format || ''
+            shortcodes: r.shortcodes || [], builder: r.builder || '', needs: r.needs || '', notes: res.notes || [], format: res.format || '',
+            ...(res.entryId && {entryId: res.entryId})
         };
     });
     const tally = {};
@@ -770,7 +891,7 @@ function buildReport({job, plan, results, redirectResults, meta, user, started,
         comments: commentsMade,
         redirects,
         failed,
-        rebuild: items.filter(i => i.shortcodes.length || i.builder).length
+        rebuild: items.filter(i => i.shortcodes.length || i.builder || i.needs).length
     };
     const run = {
         id: job.id,
@@ -784,7 +905,7 @@ function buildReport({job, plan, results, redirectResults, meta, user, started,
         durationMs: Date.now() - started,
         summary
     };
-    return {run, options: plan.options, items, redirects: redirectResults, notes: [...plan.notes, ...commentErrors.slice(0, 50)], blogBase: plan.blogBase};
+    return {run, options: plan.options, items, redirects: redirectResults, notes: [...plan.notes, ...(plan.summary.products?.notes || []), ...commentErrors.slice(0, 50)], blogBase: plan.blogBase, shopBase: plan.shopBase};
 }
 
 // ---- The request hook: WordPress's query addresses ------------------------

package/server/services/wpImport/plan.js

@@ -14,12 +14,24 @@
  * Addresses: a page keeps its WordPress address where the permalink is known
  * (/about/team), else its parent chain of slugs. Posts go to the Blog's base
  * (/blog/<slug>), as Blog posts or - without the Blog - as pages there.
+ * WooCommerce products go to the Shop (<shop>/<slug>) when one is switched on
+ * (see ./woo.js); WooCommerce's own cart, checkout, account and shop pages are
+ * then not imported - their old addresses lead to the Shop's.
  *
  * @module services/wpImport/plan
  */
 import {detectBuilder, findShortcodes} from './convert.js';
 import {hostOf} from './wxr.js';
 import {FETCH_PORTS, portOf} from './fetch.js';
+import {readWooProducts, shopProductInput, wooPageRole} from './woo.js';
+
+/** Addresses under the Shop's that are its own pages, never a product's. */
+const SHOP_RESERVED = ['cart', 'checkout', 'basket', 'account', 'order'];
+/** WooCommerce content types that are records, not content - never imported, and said so. */
+const WOO_RECORDS = {
+    shop_order: 'orders', shop_order_placehold: 'orders', shop_order_refund: 'refunds', shop_coupon: 'coupons',
+    shop_subscription: 'subscriptions', shop_webhook: 'webhooks', wc_user_membership: 'memberships'
+};
 
 export const MEDIA_EXTENSIONS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'avif', 'bmp', 'ico', 'tif', 'tiff',
     'pdf', 'txt', 'csv', 'doc', 'docx', 'xls', 'xlsx', 'mp4', 'webm', 'ogv', 'mp3', 'ogg', 'wav']);
@@ -171,6 +183,7 @@ export function isoDate(gmt, local) {
  * @param {Set<string>} site.mediaNames      - files in the media folder, lower case
  * @param {Set<string>} site.menuSlugs
  * @param {{available: boolean, basePath: string, posts: Map<string,{slug, hash}>, postSlugs: Set<string>, categories: Map<string,string>}} site.blog
+ * @param {{available: boolean, reason?: string, basePath: string, currency: string, decimals: number, products: Map<string,{slug, hash}>, productSlugs: Set<string>}} [site.shop]
  * @param {boolean} site.redirectsAvailable  - SEO is running (its redirects take the old addresses)
  * @param {Set<string>} site.redirectFroms   - addresses that already redirect
  * @param {object} [mapping] - what earlier runs of this import made ({items: {key: {...}}})
@@ -181,6 +194,8 @@ export function isoDate(gmt, local) {
  * @param {boolean} [options.menus=true]
  * @param {boolean} [options.redirects=true]
  * @param {boolean} [options.drafts=true] - import drafts, pending and private items (as drafts)
+ * @param {boolean} [options.products=true] - WooCommerce products to the Shop (when one is on)
+ * @param {number} [options.now] - the time sales are judged at (tests)
  * @param {Object<string,'skip'|'overwrite'|'import'>} [options.choices] - per item key
  * @param {Set<string>|null} [options.zipPaths] - uploads-relative paths in the uploaded zip
  * @returns {object}
@@ -188,7 +203,7 @@ export function isoDate(gmt, local) {
 export function planImport(wxr, site, mapping = {}, options = {}) {
     const opt = {
         posts: site.blog?.available ? 'blog' : 'pages',
-        media: 'download', comments: true, menus: true, redirects: true, drafts: true, choices: {}, zipPaths: null,
+        media: 'download', comments: true, menus: true, redirects: true, drafts: true, products: true, choices: {}, zipPaths: null,
         ...options
     };
     if (opt.posts === 'blog' && !site.blog?.available) opt.posts = 'pages';
@@ -198,6 +213,12 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     const blogBase = cleanPath(site.blog?.basePath || '/blog');
     // Posts as pages: under the Blog's address - unless a Blog is on, which answers there itself.
     const pagesBase = site.blog?.available ? '/posts' : blogBase;
+    const shop = site.shop || {available: false};
+    const shopOn = Boolean(shop.available && opt.products);
+    const shopBase = cleanPath(shop.basePath || '/shop');
+    const shopAt = (sub = '') => `${shopBase === '/' ? '' : shopBase}${sub}` || '/';
+    const wooProducts = readWooProducts(wxr);
+    const extraRedirects = [];
     const items = [];
     const notes = [];
     const byId = new Map(wxr.items.map(it => [it.id, it]));
@@ -249,9 +270,21 @@ 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);
+    const WOO_PAGE = {
+        cart: {to: '/cart', what: 'cart'}, checkout: {to: '/cart', what: 'checkout'},
+        account: {to: '/account', what: 'account page'}, shop: {to: '', what: 'shop page'}
+    };
     for (const it of orderedPages) {
         const key = `page:${it.id}`;
         const oldPath = oldPathOf(it.link, wxr.site);
+        const role = shopOn && (wooProducts.length || it.slug === 'shop') ? wooPageRole(it) : '';
+        if (role && choices[key] !== 'import') {
+            const w = WOO_PAGE[role];
+            const to = shopAt(w.to);
+            push({...docRow(it, key, 'page', oldPath), shortcodes: [], builder: '', action: 'skip', target: to, reason: `WooCommerce's ${w.what} - the Shop has its own at ${to}${oldPath ? ', and the old address leads there' : ''}.`});
+            if (oldPath) extraRedirects.push({from: oldPath, to, key});
+            continue;
+        }
         let wanted = oldPath ? cleanPath(relative(oldPath, base)) : '';
         if (!wanted || wanted === '/' && oldPath !== null && relative(oldPath, base) !== '/') wanted = '';
         if (!wanted) {
@@ -277,15 +310,79 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         else planDocument({it, key, kind: 'post', wanted: `${pagesBase === '/' ? '' : pagesBase}/${slug}`, oldPath, statusMap: PAGE_STATUS});
     }
 
+    // ---- WooCommerce products (to the Shop) ----
+    const takenProductSlugs = new Set([...(shop.productSlugs || []), ...SHOP_RESERVED]);
+    const productTypes = {};
+    const primaryCats = new Set();
+    const usedCats = new Set();
+    const usedTags = new Map();
+    const now = Number.isFinite(opt.now) ? opt.now : Date.now();
+    for (const p of wooProducts) {
+        const it = p.item;
+        const key = `product:${it.id}`;
+        const oldPath = oldPathOf(it.link, wxr.site);
+        productTypes[p.type] = (productTypes[p.type] || 0) + 1;
+        const facts = shopProductInput(p, {decimals: shop.decimals ?? 2, now, published: it.status === 'publish' && !it.password});
+        const said = facts.notes.length ? ` ${sentence(facts.notes)}` : '';
+        const row = {
+            key, kind: 'product', wpId: it.id, title: it.title || `(untitled product ${it.id})`, oldUrl: it.link, oldPath, wpStatus: it.status,
+            status: facts.input.status, productType: p.type, variants: facts.input.variants.length, needs: facts.needs,
+            shortcodes: findShortcodes(it.content), builder: ''
+        };
+        const was = mapped[key];
+        const why = excluded(it);
+        const live = (r) => { if (r.action !== 'skip') { if (facts.input.category) primaryCats.add(facts.input.category); for (const c of p.categories) usedCats.add(c.slug); for (const t of p.tags) usedTags.set(slugify(t), t); } return push(r); };
+        if (!shop.available) { push({...row, action: 'skip', reason: shop.reason || 'Switch on the Shop to bring these in.'}); continue; }
+        if (!opt.products) { push({...row, action: 'skip', reason: 'Products are not being imported.'}); continue; }
+        if (choices[key] === 'skip') { push({...row, action: 'skip', reason: 'You chose to skip it.'}); continue; }
+        if (why) { push({...row, action: 'skip', reason: why}); continue; }
+        if (p.type === 'grouped') {
+            push({...row, action: 'skip', reason: `A grouped product - the Shop has no groups. ${p.children.length ? `Its ${p.children.length} product${p.children.length === 1 ? ' is' : 's are'} imported on ${p.children.length === 1 ? 'its' : 'their'} own; ` : ''}rebuild the group as a page with [shop-products] if you need it.`});
+            continue;
+        }
+        if (was?.entryId) {
+            const nowHere = shop.products?.get(was.entryId);
+            if (!nowHere) {
+                if (choices[key] !== 'import') { push({...row, action: 'skip', target: shopAt(`/${was.slug}`), reason: 'Deleted from the Shop since it was imported - choose "Import again" to bring it back.'}); continue; }
+            } else {
+                const edited = nowHere.hash !== was.hash;
+                const target = shopAt(`/${nowHere.slug}`);
+                takenProductSlugs.add(nowHere.slug);
+                if (edited && choices[key] !== 'overwrite') { live({...row, action: 'keep', target, slug: nowHere.slug, entryId: was.entryId, reason: 'Edited in the Shop since it was imported - left as it is.'}); continue; }
+                live({...row, action: 'update', target, slug: nowHere.slug, entryId: was.entryId, reason: `${edited ? 'Edited here since - you chose to overwrite it.' : ''}${said}`.trim()});
+                continue;
+            }
+        }
+        const slug = slugify(it.slug) || slugify(it.title) || `product-${it.id}`;
+        const free = freePath(slug, takenProductSlugs);
+        takenProductSlugs.add(free);
+        if (free !== slug) live({...row, action: 'rename', target: shopAt(`/${free}`), slug: free, wanted: shopAt(`/${slug}`), reason: `The Shop has a product at ${shopAt(`/${slug}`)} - imported as ${free}.${said}`});
+        else live({...row, action: 'create', target: shopAt(`/${free}`), slug: free, reason: said.trim()});
+    }
+
     // Everything else WordPress exports, counted so nothing vanishes silently.
     const others = {};
+    const records = {};
     for (const it of wxr.items) {
-        if (['page', 'post', 'attachment', 'nav_menu_item'].includes(it.type)) continue;
+        if (['page', 'post', 'attachment', 'nav_menu_item', 'product', 'product_variation'].includes(it.type)) continue;
+        if (WOO_RECORDS[it.type]) { records[WOO_RECORDS[it.type]] = (records[WOO_RECORDS[it.type]] || 0) + 1; continue; }
         others[it.type] = (others[it.type] || 0) + 1;
     }
     for (const [type, n] of Object.entries(others)) {
         notes.push(`${n} "${type}" item${n === 1 ? '' : 's'} (a theme or plugin's own content type) ${n === 1 ? 'is' : 'are'} not imported.`);
     }
+    // What the Products section of the preview says (and the report keeps).
+    const productNotes = [];
+    const reviews = wooProducts.reduce((n, p) => n + p.item.comments.filter(c => c.approved === '1' && (!c.type || c.type === 'review' || c.type === 'comment')).length, 0);
+    if (wooProducts.length || Object.keys(records).length) {
+        const found = Object.entries(records).map(([what, n]) => `${n} ${n === 1 ? what.replace(/s$/, '') : what}`);
+        productNotes.push(`Orders, customers, coupons, reviews, tax and shipping settings are not imported${found.length ? ` (this export has ${found.join(', ')})` : ''} - they hold people's personal details or settings a person should check. Set tax and delivery in the Shop's settings.`);
+    }
+    if (reviews) productNotes.push(`${reviews} product review${reviews === 1 ? ' is' : 's are'} not imported - reviews could come across in a later version.`);
+    if (wooProducts.length && shop.available && opt.products) {
+        productNotes.push(`WooCommerce's currency is not in the export: prices are read as ${shop.currency || 'GBP'}, the Shop's currency. Check them if the old shop used another.`);
+        if (wooProducts.some(p => Number(p.weight) > 0 || p.variations.some(v => Number(v.weight) > 0))) productNotes.push('Weights are read as kilograms (WooCommerce\'s usual unit - the export does not say which it used).');
+    }
 
     // ---- Categories (Blog only) ----
     if (opt.posts === 'blog') {
@@ -349,6 +446,33 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
             if (r.oldPath && r.oldPath !== r.target) redirects.push({from: r.oldPath, to: r.target, key: r.key});
         } else if (r.kind === 'media') {
             query.attachment_id[r.wpId] = r.target;
+        } else if (r.kind === 'product') {
+            query.p[r.wpId] = r.target;
+            for (const v of wooProducts.find(p => p.id === r.wpId)?.variations || []) query.p[v.id] = r.target;
+            if (r.oldPath && r.oldPath !== r.target) redirects.push({from: r.oldPath, to: r.target, key: r.key});
+            const wpSlug = byId.get(r.wpId)?.slug;
+            if (wpSlug) redirects.push({from: `${base}/product/${wpSlug}`, to: r.target, key: `${r.key}/product`});
+        }
+    }
+    redirects.push(...extraRedirects);
+    // Product categories and tags: to the storefront, filtered.
+    if (shopOn) {
+        const cats = (wxr.terms || []).filter(t => t.taxonomy === 'product_cat');
+        const bySlug = new Map(cats.map(t => [t.slug, t]));
+        const chain = (t) => {
+            const out = [];
+            for (let c = t, n = 0; c && n < 10; c = bySlug.get(c.parent), n++) out.unshift(c.slug);
+            return out.join('/');
+        };
+        // A category some product is filed under -> the storefront filtered to it; one that became a tag -> a search
+        // for it; one no imported product is in (a parent, an empty one) -> the storefront.
+        for (const t of cats) {
+            const to = primaryCats.has(t.name) ? shopAt(`?category=${encodeURIComponent(t.name)}`)
+                : usedCats.has(t.slug) ? shopAt(`?q=${encodeURIComponent(t.name.toLowerCase())}`) : shopAt();
+            redirects.push({from: `${base}/product-category/${chain(t)}`, to, key: `product_cat:${t.slug}`});
+        }
+        for (const [s, name] of usedTags) {
+            if (s) redirects.push({from: `${base}/product-tag/${s}`, to: shopAt(`?q=${encodeURIComponent(String(name).toLowerCase())}`), key: `product_tag:${s}`});
         }
     }
     if (opt.posts === 'blog') {
@@ -375,6 +499,16 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         if (posts.length) redirects.push({from: `${base}/feed`, to: `${blogBase}/feed.xml`, key: 'feed'});
     }
     const liveTargets = new Set(items.filter(live).map(x => x.target));
+    // An address the Shop answers itself (one of its products, its cart…) is never redirected away.
+    const shopSlugs = new Set([...(shop.productSlugs || []), ...SHOP_RESERVED]);
+    const shopOwns = (from) => {
+        if (!shop.available) return false;
+        const prefix = shopBase === '/' ? '/' : `${shopBase}/`;
+        if (from === shopBase) return true;
+        if (!from.startsWith(prefix)) return false;
+        const rest = from.slice(prefix.length);
+        return shopSlugs.has(rest.split('/')[0]);
+    };
     const redirectPlan = [];
     const ownRedirects = new Set(Object.values(mapping.redirects || {}).map(r => r.from));
     const seen = new Set();
@@ -391,12 +525,14 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         else if (from === '/' || from === '/*') { action = 'skip'; reason = 'That would redirect the home page.'; }
         else if (liveTargets.has(from)) { action = 'skip'; reason = 'An imported item takes that address.'; }
         else if (site.pagePaths.has(from) && !ownPaths.has(from)) { action = 'skip'; reason = 'A page on this site has that address - it is not redirected.'; }
+        else if (shopOwns(from)) { action = 'skip'; reason = 'The Shop has a page at that address - it is not redirected.'; }
         else if (site.redirectFroms.has(from) && !ownRedirects.has(from)) { action = 'skip'; reason = 'This site already redirects it.'; }
         else if (ownRedirects.has(from)) action = 'update';
         redirectPlan.push({from, to, key: r.key, action, reason});
     }
 
     for (const r of items) if (r.builder) notes.push(`"${r.title}" was built with ${r.builder} - its layout will need rebuilding.`);
+    const productRows = items.filter(r => r.kind === 'product');
     const shortcodeCount = items.reduce((n, r) => n + (r.shortcodes?.length || 0), 0);
 
     const summary = {
@@ -404,13 +540,25 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         comments,
         redirects: redirectPlan.filter(r => r.action !== 'skip').length,
         shortcodes: shortcodeCount,
-        builders: items.filter(r => r.builder).length
+        builders: items.filter(r => r.builder).length,
+        products: {
+            total: wooProducts.length,
+            types: productTypes,
+            onSale: productRows.filter(r => r.action !== 'skip' && r.action !== 'keep' && r.status === 'active').length,
+            drafts: productRows.filter(r => r.action !== 'skip' && r.action !== 'keep' && r.status !== 'active').length,
+            rebuild: productRows.filter(r => r.needs).length,
+            reviews,
+            records,
+            notes: productNotes,
+            shop: {available: Boolean(shop.available), basePath: shopBase, currency: shop.currency || '', reason: shop.reason || ''}
+        }
     };
     return {
         source: sourceKey(wxr.site),
         site: {title: wxr.site.title, url: wxr.site.baseSiteUrl || wxr.site.link, wxrVersion: wxr.site.wxrVersion, hosts: wxr.site.hosts},
         options: {...opt, zipPaths: undefined, anyPort: undefined, choices},
         blogBase,
+        shopBase,
         items,
         redirects: redirectPlan,
         query,
@@ -487,6 +635,11 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     }
 }
 
+/** Notes as one sentence each: "it had no price; ..." -> "It had no price. …" */
+function sentence(list) {
+    return list.map(n => { const t = String(n).trim(); return t ? `${t[0].toUpperCase()}${t.slice(1)}${/[.!?]$/.test(t) ? '' : '.'}` : ''; }).filter(Boolean).join(' ');
+}
+
 /** One key per WordPress site, so two different sites imported here never share a mapping. */
 export function sourceKey(site) {
     const u = site.baseSiteUrl || site.baseBlogUrl || site.link || site.title || 'wordpress';
@@ -521,9 +674,11 @@ export function menuItems(wxr, menuSlug, addressFor, linkFor, categoryAddress =
             url = addressFor(objectId);
             if (!text) text = byId.get(objectId)?.title || '';
         } else if (m._menu_item_type === 'taxonomy') {
-            const term = wxr.categories.find(c => c.id === objectId) || wxr.tags.find(t => t.id === objectId);
+            const other = m._menu_item_object && m._menu_item_object !== 'category' && m._menu_item_object !== 'post_tag'
+                ? (wxr.terms || []).find(t => t.taxonomy === m._menu_item_object && t.id === objectId) : null;
+            const term = other || wxr.categories.find(c => c.id === objectId) || wxr.tags.find(t => t.id === objectId);
             if (term) {
-                url = categoryAddress.get(term.slug) || null;
+                url = categoryAddress.get(other ? `${other.taxonomy}:${term.slug}` : term.slug) || null;
                 if (!text) text = term.name;
             }
         } else if (m._menu_item_type === 'post_type_archive') {