domma-cms 1.6.34 → 1.6.35

package/plugins/shopping-cart/lib/sales.js

@@ -0,0 +1,193 @@
+/**
+ * The Sales report. PURE: orders in, figures out - for the Sales tab and its CSV.
+ *
+ * A sale is an order that took money (paid, fulfilled - or refunded later), dated by when it was PAID, in the
+ * shop's time zone. A refund is dated by when it was refunded, so a period's net is what really stayed.
+ *
+ * Every line is put to a SOURCE, from what the order already says about itself:
+ *   takeaway  - an order Takeaway placed (`ref: 'takeaway:…'`)
+ *   downloads - a line for a product Shopping Cart Pro gave a download link or licence key for
+ *   addons    - an order another extension placed (any other `ref` - Cards Pro's credits, …)
+ *   shop      - everything else: the Shop's own products
+ *
+ * Platform commission (lib/commission.js) is the figure each order was given when it was paid; it counts on the day it
+ * was paid and comes back on the day of a refund.
+ *
+ * Amounts are minor units. Line amounts are before discounts; the order-level figures (discount, delivery, tax)
+ * are reported beside them, not shared out across sources.
+ *
+ * @module shopping-cart/lib/sales
+ */
+
+export const SOURCES = {shop: 'Shop', downloads: 'Downloads & keys', takeaway: 'Takeaway', addons: 'Other add-ons'};
+const PROVIDERS = {stripe: 'Card (Stripe)', paypal: 'PayPal', offline: 'Paid offline', free: 'Free'};
+const TOOK = new Set(['paid', 'fulfilled', 'refunded']);
+const DAY = 86400000;
+
+const parts = new Map();
+/** The shop's calendar date of an instant: 'YYYY-MM-DD'. */
+export function dateIn(t, tz = 'Europe/London') {
+    if (!parts.has(tz)) {
+        try { parts.set(tz, new Intl.DateTimeFormat('en-CA', {timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit'})); }
+        catch { parts.set(tz, new Intl.DateTimeFormat('en-CA', {timeZone: 'Europe/London', year: 'numeric', month: '2-digit', day: '2-digit'})); }
+    }
+    return parts.get(tz).format(new Date(t));
+}
+
+const addDays = (date, n) => { const [y, m, d] = date.split('-').map(Number); return new Date(Date.UTC(y, m - 1, d + n)).toISOString().slice(0, 10); };
+const weekday = (date) => { const [y, m, d] = date.split('-').map(Number); return new Date(Date.UTC(y, m - 1, d)).getUTCDay(); };
+
+/** The period a date falls in: the day, the Monday of its week, or the 1st of its month. */
+export function periodOf(date, by) {
+    if (by === 'month') return `${date.slice(0, 7)}-01`;
+    if (by === 'week') return addDays(date, -((weekday(date) + 6) % 7));
+    return date;
+}
+
+/** Every period from `from` to `to`, in order, so empty ones show as empty. */
+export function periodsBetween(from, to, by) {
+    const out = [];
+    let p = periodOf(from, by);
+    const last = periodOf(to, by);
+    for (let i = 0; p <= last && i < 800; i++) {
+        out.push(p);
+        if (by === 'month') { const [y, m] = p.split('-').map(Number); p = new Date(Date.UTC(y, m, 1)).toISOString().slice(0, 10); }
+        else p = addDays(p, by === 'week' ? 7 : 1);
+    }
+    return out;
+}
+
+/** Which source an order line belongs to. */
+export function sourceOf(order, line) {
+    const ref = String(order.data?.ref || '');
+    if (ref.startsWith('takeaway:')) return 'takeaway';
+    if (ref) return 'addons';
+    const pro = order.data?.ext?.['shopping-cart-pro'];
+    const digital = new Set([...(pro?.downloads || []), ...(pro?.keys || [])].map(x => x.productId));
+    if (line.productId && digital.has(line.productId)) return 'downloads';
+    return 'shop';
+}
+
+/** One order's money, split the way the report shows it. */
+export function orderFigures(o) {
+    const d = o.data;
+    const adj = d.adjustments || [];
+    const sum = (f) => adj.filter(f).reduce((n, a) => n + a.amount, 0);
+    return {
+        subtotal: d.subtotal || 0,
+        discount: -sum(a => a.stage === 'discount'),
+        delivery: sum(a => a.stage === 'shipping'),
+        taxAdded: sum(a => a.stage === 'tax' && !a.included),
+        taxIncluded: sum(a => a.stage === 'tax' && a.included),
+        total: d.total || 0
+    };
+}
+
+/**
+ * The report for `from`..`to` (dates, both included), in periods of `by`.
+ *
+ * @param {{id, data, meta}[]} orders
+ * @param {{from: string, to: string, by?: 'day'|'week'|'month', timeZone?: string}} opts
+ */
+export function salesReport(orders, {from, to, by = 'day', timeZone = 'Europe/London'}) {
+    const inRange = (date) => date >= from && date <= to;
+    const periods = new Map(periodsBetween(from, to, by).map(p => [p, {period: p, orders: 0, takings: 0, refunds: 0, commission: 0}]));
+    const totals = {orders: 0, items: 0, subtotal: 0, discount: 0, delivery: 0, taxAdded: 0, taxIncluded: 0, takings: 0, refunds: 0, refundCount: 0,
+        commission: 0, commissionBack: 0};
+    const sources = Object.fromEntries(Object.keys(SOURCES).map(k => [k, {key: k, label: SOURCES[k], orders: 0, amount: 0}]));
+    const methods = new Map();
+    const takeaway = {collect: 0, deliver: 0};
+
+    for (const o of orders) {
+        const d = o.data || {};
+        if (!TOOK.has(d.status)) continue;
+        const paidDate = dateIn(d.paidAt || o.meta?.createdAt, timeZone);
+        if (inRange(paidDate)) {
+            const f = orderFigures(o);
+            totals.orders++;
+            for (const k of ['subtotal', 'discount', 'delivery', 'taxAdded', 'taxIncluded']) totals[k] += f[k];
+            totals.takings += f.total;
+            const seen = new Set();
+            for (const l of d.lines || []) {
+                const s = sourceOf(o, l);
+                sources[s].amount += l.lineTotal || 0;
+                totals.items += l.qty || 0;
+                if (!seen.has(s)) { sources[s].orders++; seen.add(s); }
+            }
+            if (String(d.ref || '').startsWith('takeaway:')) takeaway[d.delivery === 'ship' ? 'deliver' : 'collect']++;
+            const m = methods.get(d.provider) || {key: d.provider, label: PROVIDERS[d.provider] || d.provider || 'Other', orders: 0, takings: 0};
+            m.orders++; m.takings += f.total;
+            methods.set(d.provider, m);
+            const c = d.commission?.amount || 0;
+            totals.commission += c;
+            const p = periods.get(periodOf(paidDate, by));
+            if (p) { p.orders++; p.takings += f.total; p.commission += c; }
+        }
+        if (d.status === 'refunded') {
+            const refDate = dateIn(d.refundedAt || d.paidAt || o.meta?.createdAt, timeZone);
+            if (inRange(refDate)) {
+                totals.refunds += d.total || 0;
+                totals.refundCount++;
+                const p = periods.get(periodOf(refDate, by));
+                if (p) p.refunds += d.total || 0;
+            }
+        }
+        if (d.commission?.reversed) {
+            const backDate = dateIn(d.commission.reversedAt || d.refundedAt || o.meta?.createdAt, timeZone);
+            if (inRange(backDate)) {
+                totals.commissionBack += d.commission.amount || 0;
+                const p = periods.get(periodOf(backDate, by));
+                if (p) p.commission -= d.commission.amount || 0;
+            }
+        }
+    }
+    return {
+        from, to, by,
+        totals: {...totals, net: totals.takings - totals.refunds, average: totals.orders ? Math.round(totals.takings / totals.orders) : 0,
+            commissionNet: totals.commission - totals.commissionBack, afterCommission: totals.takings - totals.refunds - (totals.commission - totals.commissionBack)},
+        periods: [...periods.values()].map(p => ({...p, net: p.takings - p.refunds})),
+        sources: Object.values(sources).filter(s => s.orders || s.key === 'shop'),
+        methods: [...methods.values()].sort((a, b) => b.takings - a.takings),
+        takeaway
+    };
+}
+
+/** The named ranges the Sales tab offers, as {from, to} dates for `today`. */
+export function rangeFor(name, today) {
+    const [y, m] = today.split('-').map(Number);
+    const monthStart = (yy, mm) => new Date(Date.UTC(yy, mm - 1, 1)).toISOString().slice(0, 10);
+    switch (name) {
+        case 'today': return {from: today, to: today};
+        case 'week': return {from: periodOf(today, 'week'), to: today};
+        case 'last7': return {from: addDays(today, -6), to: today};
+        case 'month': return {from: monthStart(y, m), to: today};
+        case 'lastmonth': return {from: monthStart(y, m - 1), to: addDays(monthStart(y, m), -1)};
+        case 'last30': return {from: addDays(today, -29), to: today};
+        case 'year': return {from: `${y}-01-01`, to: today};
+        default: return {from: addDays(today, -29), to: today};
+    }
+}
+
+const csvCell = (v) => { const s = String(v ?? ''); return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s; };
+const pounds = (n) => ((n || 0) / 100).toFixed(2);
+
+/** One row per order sold or refunded in the range - for the accountant. */
+export function salesCsv(orders, {from, to, timeZone = 'Europe/London'}) {
+    const rows = [['Order', 'Paid', 'Status', 'Refunded', 'Sources', 'Payment', 'Customer', 'Subtotal', 'Discount', 'Delivery', 'Tax added', 'Tax included', 'Total', 'Commission', 'Commission rate']];
+    const list = orders.filter(o => TOOK.has(o.data?.status)).filter(o => {
+        const paid = dateIn(o.data.paidAt || o.meta?.createdAt, timeZone);
+        const refunded = o.data.refundedAt ? dateIn(o.data.refundedAt, timeZone) : '';
+        return (paid >= from && paid <= to) || (refunded && refunded >= from && refunded <= to);
+    }).sort((a, b) => String(a.data.paidAt || a.meta?.createdAt).localeCompare(String(b.data.paidAt || b.meta?.createdAt)));
+    for (const o of list) {
+        const d = o.data;
+        const f = orderFigures(o);
+        rows.push([`#${d.number}`, dateIn(d.paidAt || o.meta?.createdAt, timeZone), d.status, d.refundedAt ? dateIn(d.refundedAt, timeZone) : '',
+            [...new Set((d.lines || []).map(l => SOURCES[sourceOf(o, l)]))].join('; '), PROVIDERS[d.provider] || d.provider, d.customer?.name || d.email || '',
+            pounds(f.subtotal), pounds(f.discount), pounds(f.delivery), pounds(f.taxAdded), pounds(f.taxIncluded), pounds(f.total),
+            d.commission ? pounds(d.commission.reversed ? 0 : d.commission.amount) : '', d.commission ? `${d.commission.percent}% + ${pounds(d.commission.fixed)}` : '']);
+    }
+    return rows.map(r => r.map(csvCell).join(',')).join('\r\n') + '\r\n';
+}
+
+export {DAY};

package/plugins/shopping-cart/lib/shop.js

@@ -18,6 +18,14 @@ import {cleanProduct} from '../public/lib/products.js';
 import {NEXT, SOLD, canMove} from '../public/lib/orders.js';
 import {currencyOf} from '../public/lib/money.js';
 import {cartRegistry} from './extensions.js';
+import {commissionFor, currentCommission} from './commission.js';
+
+/** The platform's commission on a sale being paid now - kept if it already has one. */
+function commissionOn(d, at) {
+    if (d.commission) return {};
+    const c = commissionFor({data: d}, currentCommission().rates, at);
+    return c ? {commission: c} : {};
+}
 import defaults from '../config.js';
 
 export const NAME = 'shopping-cart';
@@ -98,6 +106,7 @@ export function cleanSettings(input, current) {
     out.lowStockAt = Math.max(0, Math.min(1000, Math.round(Number(input.lowStockAt ?? current.lowStockAt) || 0)));
     out.showStockLeft = bool('showStockLeft');
     out.termsUrl = str('termsUrl', 300);
+    out.accounts = bool('accounts');
     if (out.termsUrl && !/^(\/(?!\/)|https?:\/\/)/.test(out.termsUrl)) errors.termsUrl = 'A page on this site (/terms) or a full https:// address.';
 
     const countries = Array.isArray(input.countries) ? input.countries : (current.countries || ['GB']);
@@ -360,6 +369,7 @@ export function markPaid(id, info = {}) {
             stockTaken: true,
             ...(info.ref ? {providerRef: info.ref} : {}),
             ...(info.payment ? {paymentRef: info.payment} : {}),
+            ...commissionOn(d, now),
             history: [...(d.history || []), {at: now, status: 'paid', by: info.by || d.provider, note: info.note || ''}]
         });
         return {order, changed: true, from: d.status};
@@ -384,6 +394,9 @@ export function moveOrder(id, to, {by = 'admin', note = '', restock = false, tra
         const patch = {status: to, history: [...(d.history || []), {at: now, status: to, by, note: String(note || '').slice(0, 500)}]};
         if (to === 'paid' && !d.stockTaken) { await moveStock(d, -1); patch.stockTaken = true; }
         if (to === 'paid' && !d.paidAt) patch.paidAt = now;
+        if (to === 'paid') Object.assign(patch, commissionOn(d, now));
+        // A refund gives the platform's commission back too (statements net it off in the month of the refund).
+        if (to === 'refunded' && d.commission && !d.commission.reversed) patch.commission = {...d.commission, reversed: true, reversedAt: now};
         if (to === 'fulfilled') {
             patch.fulfilledAt = now;
             if (tracking) patch.tracking = tracking;

package/plugins/shopping-cart/plugin.js

@@ -28,6 +28,10 @@ import {formatMoney} from './public/lib/money.js';
 import {publicProduct, byShelf} from './public/lib/products.js';
 import {cartRegistry} from './lib/extensions.js';
 import {SAMPLES} from './lib/samples.js';
+import * as accounts from './lib/accounts.js';
+import {dateIn, rangeFor, salesCsv, salesReport} from './lib/sales.js';
+import {TYPES as COMMISSION_TYPES, currentCommission, rateFor, rateText} from './lib/commission.js';
+import {getUserById} from '../../server/services/users.js';
 import {cleanCharges, cleanCustomLines, cleanLines, priceBasket} from './lib/pricing.js';
 import {badge, summarise} from './lib/summary.js';
 import * as pay from './lib/payments.js';
@@ -201,6 +205,38 @@ export default async function shoppingCart(fastify, options) {
         };
     });
 
+    /**
+     * The Sales report: ?range=today|week|last7|month|lastmonth|last30|year, or ?from=&to= (dates), and ?by=day|week|month.
+     * Dates are the shop's (settings.timeZone, Europe/London unless set).
+     */
+    const salesRange = (q, s) => {
+        const today = dateIn(Date.now(), s.timeZone || 'Europe/London');
+        const isDate = (d) => /^\d{4}-\d{2}-\d{2}$/.test(String(d || ''));
+        let {from, to} = isDate(q.from) && isDate(q.to) ? {from: q.from, to: q.to} : rangeFor(String(q.range || 'last30'), today);
+        if (from > to) [from, to] = [to, from];
+        return {from, to, today};
+    };
+    /** The platform's commission for this site, for people: each kind of sale and its rate. Read-only here. */
+    const commissionInfo = (s) => {
+        const {rates, updatedAt} = currentCommission();
+        const money = (n) => formatMoney(n, s.currency);
+        return {set: Object.keys(rates).length > 0, updatedAt,
+            rates: Object.entries(COMMISSION_TYPES).map(([k, label]) => ({key: k, label, text: rateText(rateFor(k, rates), money)}))};
+    };
+
+    fastify.get('/sales', can('read'), async (request) => {
+        const [orders, s] = await Promise.all([allOrders(), liveSettings()]);
+        const {from, to, today} = salesRange(request.query || {}, s);
+        const by = ['day', 'week', 'month'].includes(request.query?.by) ? request.query.by : 'day';
+        return {...salesReport(orders, {from, to, by, timeZone: s.timeZone || 'Europe/London'}), today, currency: s.currency, commission: commissionInfo(s)};
+    });
+    fastify.get('/sales.csv', can('read'), async (request, reply) => {
+        const [orders, s] = await Promise.all([allOrders(), liveSettings()]);
+        const {from, to} = salesRange(request.query || {}, s);
+        return reply.type('text/csv; charset=utf-8').header('Content-Disposition', `attachment; filename="sales-${from}-to-${to}.csv"`)
+            .header('Cache-Control', 'no-store').send(salesCsv(orders, {from, to, timeZone: s.timeZone || 'Europe/London'}));
+    });
+
     fastify.get('/count', can('read'), async () => {
         const [orders, settings, products] = await Promise.all([allOrders(), liveSettings(), allProducts()]);
         return badge(orders, settings, Date.now(), products);
@@ -379,7 +415,8 @@ export default async function shoppingCart(fastify, options) {
         return {
             settings: maskSettings(s),
             webhookUrl: `${siteBase(request)}/api/plugins/shopping-cart/stripe/webhook`,
-            stripeMode: pay.stripeMode(s.stripeSecretKey)
+            stripeMode: pay.stripeMode(s.stripeSecretKey),
+            commission: commissionInfo(s)
         };
     });
 
@@ -413,6 +450,78 @@ export default async function shoppingCart(fastify, options) {
         }
     });
 
+    // ---- Customer accounts (lib/accounts.js) --------------------------------------------
+    //
+    // Optional (settings.accounts). Made, confirmed and described here; signed in, refreshed and given a new
+    // password by core's own /api/auth routes. A signed-in customer sends core's Bearer token.
+
+    // A boolean, the reply sent on the side: awaiting a Fastify reply resolves (empty) once it is sent, so
+    // `if (await fail(...))` would carry on and run the route anyway.
+    const accountsOff = async (reply) => {
+        if ((await liveSettings()).accounts) return false;
+        fail(reply, 404, 'Customer accounts are not switched on.');
+        return true;
+    };
+    /** `rest` -> an absolute address under the shop, for emails. */
+    const shopLink = async (request) => {
+        const s = await liveSettings();
+        const base = siteBase(request);
+        return {s, link: (rest) => `${base}${s.shopPath}/${rest}`};
+    };
+    const accountFail = (reply, err) => fail(reply, err.status || 500, err.message, err.errors ? {errors: err.errors} : {});
+
+    fastify.post('/account/register', {config: {rateLimit: {max: 5, timeWindow: '10 minutes'}}}, async (request, reply) => {
+        if (await accountsOff(reply)) return undefined;
+        const {s, link} = await shopLink(request);
+        try {
+            return await accounts.register(request.body || {}, {link, shopTitle: s.shopTitle || 'the shop', log: request.log});
+        } catch (err) { return accountFail(reply, err); }
+    });
+
+    fastify.post('/account/confirm', {config: {rateLimit: {max: 20, timeWindow: '10 minutes'}}}, async (request, reply) => {
+        try {
+            const user = await accounts.confirm(request.body?.u, request.body?.t);
+            return {confirmed: true, email: user.email};
+        } catch (err) { return accountFail(reply, err); }
+    });
+
+    fastify.post('/account/forgot', {config: {rateLimit: {max: 5, timeWindow: '10 minutes'}}}, async (request, reply) => {
+        if (await accountsOff(reply)) return undefined;
+        const {s, link} = await shopLink(request);
+        await accounts.forgot(request.body?.email, {link, shopTitle: s.shopTitle || 'the shop', log: request.log}).catch(() => null);
+        // The same answer whoever asked: the form must not tell anyone who has an account.
+        return {ok: true};
+    });
+
+    /** The signed-in customer: details, saved addresses and the orders placed with their email. */
+    fastify.get('/account', {preHandler: [authenticate]}, async (request, reply) => {
+        const user = await getUserById(request.user.id);
+        if (!user || !user.isActive) return fail(reply, 401, 'Please sign in again.');
+        const s = await liveSettings();
+        const mine = accounts.ordersFor(await allOrders(), user.email).slice(0, 50);
+        const orders = [];
+        for (const o of mine) {
+            orders.push({id: o.id, number: o.data.number, status: o.data.status, total: o.data.total, currency: o.data.currency,
+                placedAt: o.meta?.createdAt, receipt: receiptPath(s, o), lines: (o.data.lines || []).map(l => `${l.qty} × ${l.name}${l.variantName ? ` (${l.variantName})` : ''}`),
+                parts: await registry.accountParts(o, {settings: s})});
+        }
+        return {...accounts.describe(user), orders, accounts: Boolean(s.accounts)};
+    });
+
+    fastify.put('/account', {preHandler: [authenticate]}, async (request, reply) => {
+        try {
+            const b = request.body || {};
+            return await accounts.updateDetails(request.user.id, {name: b.name, phone: b.phone, addresses: b.addresses});
+        } catch (err) { return accountFail(reply, err); }
+    });
+
+    fastify.delete('/account', {preHandler: [authenticate], config: {rateLimit: {max: 5, timeWindow: '10 minutes'}}}, async (request, reply) => {
+        try {
+            await accounts.remove(request.user.id, request.body?.password);
+            return {deleted: true};
+        } catch (err) { return accountFail(reply, err); }
+    });
+
     // ---- Shoppers --------------------------------------------------------------------
 
     fastify.get('/catalogue', async (request) => {

package/plugins/shopping-cart/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shopping-cart",
   "displayName": "Shopping Cart",
-  "version": "1.3.0",
+  "version": "1.6.0",
   "tier": "free",
   "description": "Sell from your site: products with options, stock and pictures, a storefront and a cart that follows shoppers from page to page, and checkout with Stripe, PayPal or payment offline. Orders to fulfil in the sidebar, refunds from the order.",
   "author": "Domma CMS",
@@ -45,7 +45,7 @@
     ],
     "views": {
       "plugin-shopping-cart": {
-        "entry": "shopping-cart/admin/views/shop.js?v=1.3.0",
+        "entry": "shopping-cart/admin/views/shop.js?v=1.6.0",
         "exportName": "shopView"
       }
     }

package/plugins/shopping-cart/plugin.public.js

@@ -6,6 +6,8 @@
  *   /shop/<slug>           one product
  *   /shop/cart             the basket and checkout, one page
  *   /shop/order/<id>?t=    a shopper's receipt
+ *   /shop/account          a customer's account: sign in, create one, details, addresses, orders (settings.accounts)
+ *   /shop/account/confirm?u=&t=  /shop/account/reset?t=   the links emailed to them
  *
  * Like the Blog, the pages are answered from ONE onRequest hook matching the
  * address as it is saved NOW, so moving the shop needs no restart. Every page
@@ -16,7 +18,7 @@ import {fileURLToPath} from 'url';
 import {renderBlogPage} from '../../server/services/renderer.js';
 import {parseMarkdown} from '../../server/services/markdown.js';
 import {byShelf, safeImage} from './public/lib/products.js';
-import {cartHtml, esc, productHtml, receiptHtml, scriptJson, storefrontHtml} from './lib/render.js';
+import {accountHtml, cartHtml, esc, productHtml, receiptHtml, scriptJson, storefrontHtml} from './lib/render.js';
 import {allProducts, getOrder, liveSettings, publicOrder, tokenOk} from './lib/shop.js';
 import {cartRegistry} from './lib/extensions.js';
 
@@ -31,6 +33,8 @@ export function matchShopPath(pathname, base) {
     try { parts = pathname.slice(base.length + 1).split('/').map(decodeURIComponent); } catch { return null; }
     if (parts.length === 1 && parts[0] === '') return {name: 'slash', params: {}};
     if (parts.length === 1 && (parts[0] === 'cart' || parts[0] === 'checkout' || parts[0] === 'basket')) return {name: 'cart', params: {}};
+    // Before products: a product called "account" would otherwise take the page.
+    if (parts[0] === 'account' && parts.length <= 2 && ['', 'confirm', 'reset'].includes(parts[1] || '')) return {name: 'account', params: {view: parts[1] || 'account'}};
     if (parts.length === 2 && parts[0] === 'order' && /^[\w-]{8,64}$/.test(parts[1])) return {name: 'order', params: {id: parts[1]}};
     if (parts.length === 1 && /^[a-z0-9-]{1,80}$/.test(parts[0])) return {name: 'product', params: {slug: parts[0]}};
     return null;
@@ -112,6 +116,18 @@ export default async function shopPublic(fastify) {
             });
         },
 
+        async account(request, reply, s, {view}) {
+            if (!s.accounts) return null;
+            return send(reply, request, s, {
+                page: 'account',
+                body: accountHtml({settings: s, view}),
+                title: view === 'reset' ? 'Set a new password' : view === 'confirm' ? 'Confirm your account' : `Your account - ${s.shopTitle || 'Shop'}`,
+                urlPath: `${s.shopPath}/account`,
+                noindex: true,
+                extra: {account: {view}}
+            });
+        },
+
         async order(request, reply, s, {id}) {
             let entry = await getOrder(id);
             if (!entry || !tokenOk(entry, request.query?.t)) return null;