@aglyn/plugins-commerce 1.0.0-beta.230 → 1.0.0-beta.231

package/src/lib/server/order-notifications.js

@@ -0,0 +1,567 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import * as Aglyn from "@aglyn/aglyn/server";
+import { pluginSmsMessaging } from "@aglyn/aglyn/plugin-manager/plugin-sms-messaging";
+import { resolveSiteTimeZone } from "@aglyn/aglyn/app-utils/collection-entry-date";
+import { resolveHostToken } from "@aglyn/aglyn/app-utils/host-tokens";
+import { firebaseAdmin, getOrgForHost, hostSendingIdentity, meterHostEmail, renderHostEmailWithTokens } from "@aglyn/tenant-data-admin";
+import { isEmailConfigured, sendEmail } from "@aglyn/shared-util-email";
+import * as CommerceModel from "../model/index.js";
+import { mintDownloadToken } from "./download.js";
+import { orderStatusUrl } from "./order-status-token.js";
+async function readStore(firestore, hostId) {
+    var _ref, _ref1, _settings_currency;
+    var _settingsSnapshot_data, _hostSnapshot_data;
+    const hostRef = firestore.collection('hosts').doc(hostId);
+    const [hostSnapshot, settingsSnapshot] = await Promise.all([
+        hostRef.get().catch(()=>null),
+        hostRef.collection('settings').doc('store').get().catch(()=>null)
+    ]);
+    const settings = (_ref = settingsSnapshot == null ? void 0 : (_settingsSnapshot_data = settingsSnapshot.data) == null ? void 0 : _settingsSnapshot_data.call(settingsSnapshot)) != null ? _ref : {};
+    return {
+        firestore,
+        hostRef,
+        host: (_ref1 = hostSnapshot == null ? void 0 : (_hostSnapshot_data = hostSnapshot.data) == null ? void 0 : _hostSnapshot_data.call(hostSnapshot)) != null ? _ref1 : {},
+        settings,
+        currency: String((_settings_currency = settings['currency']) != null ? _settings_currency : 'USD') || 'USD'
+    };
+}
+function lineLabel(line) {
+    return `${line.quantity}× ${line.name}${line.variantLabel ? ` (${line.variantLabel})` : ''}`;
+}
+/** The status link, or the store's home page when no link can be minted. */ function statusLink(store, ref) {
+    var _ref, _orderStatusUrl;
+    return (_ref = (_orderStatusUrl = orderStatusUrl(store.host, ref.hostId, ref.orderId)) != null ? _orderStatusUrl : Aglyn.hostPublicOrigin({
+        cname: typeof store.host['cname'] === 'string' ? store.host['cname'] : null,
+        subdomain: typeof store.host['subdomain'] === 'string' ? store.host['subdomain'] : null
+    })) != null ? _ref : '';
+}
+/** What the moment says. `null` when it does not apply to this order. */ export function composeOrderBuyerMessage(input) {
+    var _order_lineItems, _order_timeline;
+    const { event, order, orderId, businessName, currency, statusUrl, options = {} } = input;
+    const lines = (_order_lineItems = order.lineItems) != null ? _order_lineItems : [];
+    const number = CommerceModel.formatOrderNumber(order, orderId);
+    const money = (cents)=>CommerceModel.formatOrderMoney(cents, currency);
+    const store = businessName || 'The store';
+    const base = {
+        'order.number': number,
+        'order.statusUrl': statusUrl,
+        'order.ref': orderId
+    };
+    const link = statusUrl ? `\n\nView your order: ${statusUrl}` : '';
+    const smsLink = statusUrl ? ` ${statusUrl}` : '';
+    if (event === 'receipt') {
+        var _ref, _order_amountCents, _order_licenseKeys, _input_downloadLinks, _input_receiptFooter;
+        var _order_totals;
+        const totalCents = (_ref = (_order_totals = order.totals) == null ? void 0 : _order_totals.totalCents) != null ? _ref : Number((_order_amountCents = order.amountCents) != null ? _order_amountCents : 0);
+        const licenseText = Object.entries((_order_licenseKeys = order.licenseKeys) != null ? _order_licenseKeys : {}).flatMap(([productId, keys])=>{
+            const line = lines.find((item)=>item.productId === productId);
+            return (keys != null ? keys : []).map((key)=>{
+                var _ref;
+                return `License key (${(_ref = line == null ? void 0 : line.name) != null ? _ref : 'product'}): ${key}`;
+            });
+        }).join('\n');
+        const downloads = Object.entries((_input_downloadLinks = input.downloadLinks) != null ? _input_downloadLinks : {}).map(([productId, url])=>{
+            var _ref;
+            const line = lines.find((item)=>item.productId === productId);
+            return `Download ${(_ref = line == null ? void 0 : line.name) != null ? _ref : 'your file'}: ${url}`;
+        }).join('\n');
+        const linesText = lines.map((line)=>`${lineLabel(line)} — ${money(line.unitAmountCents * line.quantity)}`).join('\n');
+        const summary = [
+            linesText,
+            licenseText,
+            downloads
+        ].filter(Boolean).join('\n\n');
+        const footer = String((_input_receiptFooter = input.receiptFooter) != null ? _input_receiptFooter : '');
+        return {
+            occurrence: 'order',
+            emailKey: CommerceModel.BUYER_NOTIFICATION_EMAIL_KEYS.receipt,
+            tokens: _extends({}, base, {
+                'order.summary': summary,
+                'order.total': money(totalCents),
+                'store.receiptFooter': footer
+            }),
+            subject: 'Receipt for your order',
+            text: `Thanks for your purchase!\n\n${summary}\n\nTotal: ${money(totalCents)}\n` + `Order ${number}` + (footer ? `\n\n${footer}` : '') + link,
+            sms: `${store}: receipt for order ${number}, ${money(totalCents)}.${smsLink}`,
+            timelineDetail: 'Receipt sent'
+        };
+    }
+    if (event === 'shipped') {
+        var _order_fulfillments, _fulfillment_trackingNumber;
+        const fulfillments = (_order_fulfillments = order.fulfillments) != null ? _order_fulfillments : [];
+        const fulfillment = options.fulfillmentId ? fulfillments.find((entry)=>entry.id === options.fulfillmentId) : [
+            ...fulfillments
+        ].sort((a, b)=>{
+            var _b_atMs, _a_atMs;
+            return ((_b_atMs = b.atMs) != null ? _b_atMs : 0) - ((_a_atMs = a.atMs) != null ? _a_atMs : 0);
+        })[0];
+        if (!fulfillment) return null;
+        // The units THIS shipment carried (AGL-3611): a partial shipment of a
+        // line names its own count, not the line's.
+        const shipped = CommerceModel.fulfillmentLineQuantities(order, fulfillment).map((entry)=>lines[entry.lineItemId] ? _extends({}, lines[entry.lineItemId], {
+                quantity: entry.quantity
+            }) : null).filter(Boolean);
+        const tracking = CommerceModel.fulfillmentTrackingUrl(fulfillment);
+        const hasTracking = Boolean(fulfillment.trackingNumber);
+        // Nothing physical left the building: a register sale handed over the
+        // counter, or a digital-only order the merchant marked fulfilled. A
+        // "your order is on its way" email for either is noise at best.
+        const physical = shipped.some((line)=>line.productType !== 'digital' && line.productType !== 'service');
+        if (!hasTracking && (order.channel === 'pos' || !physical)) return null;
+        // Shippable units still out, over every active shipment (AGL-3611).
+        const remainingUnits = CommerceModel.remainingFulfillmentLines(order).reduce((sum, entry)=>sum + entry.quantity, 0);
+        const carrier = CommerceModel.carrierLabelFor(fulfillment.carrier);
+        const trackingSentence = hasTracking ? `Tracking: ${[
+            carrier,
+            fulfillment.trackingNumber
+        ].filter(Boolean).join(' ')}${tracking ? ` — ${tracking}` : ''}` : '';
+        const remainingSentence = remainingUnits > 0 ? `${remainingUnits} more item${remainingUnits === 1 ? '' : 's'} will ship separately.` : '';
+        const summary = shipped.map(lineLabel).join('\n');
+        return {
+            occurrence: fulfillment.id,
+            emailKey: CommerceModel.BUYER_NOTIFICATION_EMAIL_KEYS.shipped,
+            tokens: _extends({}, base, {
+                'shipment.summary': summary,
+                'shipment.carrier': carrier,
+                'shipment.trackingNumber': String((_fulfillment_trackingNumber = fulfillment.trackingNumber) != null ? _fulfillment_trackingNumber : ''),
+                'shipment.tracking': trackingSentence,
+                'shipment.remaining': remainingSentence
+            }),
+            subject: `Your order ${number} has shipped`,
+            text: `${store} shipped items from order ${number}.\n\n${summary}` + (trackingSentence ? `\n\n${trackingSentence}` : '') + (remainingSentence ? `\n\n${remainingSentence}` : '') + link,
+            sms: `${store}: order ${number} has shipped.` + (tracking ? ` Track it: ${tracking}` : smsLink),
+            timelineDetail: 'Shipping confirmation sent'
+        };
+    }
+    if (event === 'delivered') {
+        // A counter sale is "delivered" the moment it is handed over.
+        if (order.channel === 'pos') return null;
+        const summary = lines.map(lineLabel).join('\n');
+        return {
+            occurrence: 'order',
+            emailKey: CommerceModel.BUYER_NOTIFICATION_EMAIL_KEYS.delivered,
+            tokens: _extends({}, base, {
+                'order.summary': summary
+            }),
+            subject: `Your order ${number} was delivered`,
+            text: `${store} marked order ${number} as delivered.\n\n${summary}` + link,
+            sms: `${store}: order ${number} was delivered.${smsLink}`,
+            timelineDetail: 'Delivery confirmation sent'
+        };
+    }
+    if (event === 'refunded') {
+        var _options_refundCents, _options_refundLineIndexes, _order_refundedCents;
+        const refundCents = Math.max(0, Math.round(Number((_options_refundCents = options.refundCents) != null ? _options_refundCents : 0)));
+        if (!(refundCents > 0)) return null;
+        const refundedLines = ((_options_refundLineIndexes = options.refundLineIndexes) != null ? _options_refundLineIndexes : []).map((index)=>lines[index]).filter(Boolean);
+        const summary = refundedLines.map(lineLabel).join('\n');
+        const note = options.fullyRefunded ? 'Your order has been refunded in full.' : 'The rest of your order is unchanged.';
+        return {
+            // The refund's own id is the occurrence; without one, the running
+            // total after this refund is (each settled refund raises it).
+            occurrence: options.refundId || `total-${Number((_order_refundedCents = order.refundedCents) != null ? _order_refundedCents : 0) || refundCents}`,
+            emailKey: CommerceModel.BUYER_NOTIFICATION_EMAIL_KEYS.refunded,
+            tokens: _extends({}, base, {
+                'refund.amount': money(refundCents),
+                'refund.summary': summary,
+                'refund.note': note
+            }),
+            subject: `Refund for your order ${number}`,
+            text: `${store} refunded ${money(refundCents)} on order ${number}.` + (summary ? `\n\n${summary}` : '') + `\n\n${note}\n\nRefunds go back to the original payment method and ` + 'usually appear within 5 to 10 business days, depending on your bank.' + link,
+            sms: `${store}: ${money(refundCents)} refunded on order ${number}.${smsLink}`,
+            timelineDetail: `Refund confirmation sent (${money(refundCents)})`
+        };
+    }
+    // cancelled
+    const summary = lines.map(lineLabel).join('\n');
+    const wasPaid = Boolean(order.paymentIntentId || order.channel === 'pos' && order.status !== 'pending' || ((_order_timeline = order.timeline) != null ? _order_timeline : []).some((entry)=>(entry == null ? void 0 : entry.event) === 'paid'));
+    const note = wasPaid ? `Questions about a payment? Reply to this email or contact ${store}.` : '';
+    return {
+        occurrence: 'order',
+        emailKey: CommerceModel.BUYER_NOTIFICATION_EMAIL_KEYS.cancelled,
+        tokens: _extends({}, base, {
+            'order.summary': summary,
+            'cancel.note': note
+        }),
+        subject: `Your order ${number} was canceled`,
+        text: `${store} canceled order ${number}.\n\n${summary}` + (note ? `\n\n${note}` : '') + link,
+        sms: `${store}: order ${number} was canceled.${smsLink}`,
+        timelineDetail: 'Cancellation notice sent'
+    };
+}
+/**
+ * Claims one message in a transaction. `true` when this caller owns the send;
+ * `false` when a marker is already there (sent, or being sent).
+ */ async function claimMessage(firestore, orderRef, marker, channel) {
+    return firestore.runTransaction(async (transaction)=>{
+        var _snapshot_get;
+        const snapshot = await transaction.get(orderRef);
+        if (!snapshot.exists) return false;
+        const sent = (_snapshot_get = snapshot.get('buyerNotifications')) != null ? _snapshot_get : {};
+        if (sent[marker]) return false;
+        transaction.update(orderRef, {
+            [`buyerNotifications.${marker}`]: {
+                state: 'sending',
+                channel,
+                atMs: Date.now()
+            }
+        });
+        return true;
+    });
+}
+/** Marks a claimed message sent and records it on the order timeline. */ async function settleMessage(firestore, orderRef, marker, channel, detail) {
+    await firestore.runTransaction(async (transaction)=>{
+        var _snapshot_data;
+        const snapshot = await transaction.get(orderRef);
+        if (!snapshot.exists) return;
+        const order = CommerceModel.liftLegacyOrder((_snapshot_data = snapshot.data()) != null ? _snapshot_data : {});
+        const atMs = Date.now();
+        transaction.update(orderRef, _extends({}, marker ? {
+            [`buyerNotifications.${marker}`]: {
+                state: 'sent',
+                channel,
+                atMs
+            }
+        } : {}, {
+            timeline: CommerceModel.appendOrderEvent(order, 'buyer-notified', `${detail} by ${channel === 'sms' ? 'text' : 'email'}`, atMs)
+        }));
+    }).catch((error)=>{
+        console.error('[order-notifications] settle failed', marker, error);
+    });
+}
+async function releaseMessage(orderRef, marker) {
+    await orderRef.update({
+        [`buyerNotifications.${marker}`]: firebaseAdmin.firestore.FieldValue.delete()
+    }).catch(()=>undefined);
+}
+async function deliverEmail(store, ref, to, message, context) {
+    var _ref;
+    const designed = await renderHostEmailWithTokens(store.firestore, ref.hostId, message.emailKey, message.tokens);
+    const org = await getOrgForHost(ref.hostId).catch(()=>null);
+    await sendEmail(_extends({
+        to,
+        subject: (_ref = designed == null ? void 0 : designed.subject) != null ? _ref : message.subject,
+        text: (designed == null ? void 0 : designed.text) || message.text
+    }, (designed == null ? void 0 : designed.html) ? {
+        html: designed.html
+    } : {}, {
+        fromName: Aglyn.resolveBrandingProfile(org == null ? void 0 : org.org).fromName,
+        sendingIdentity: await hostSendingIdentity(ref.hostId),
+        audience: 'tenant',
+        context,
+        // Owed to the recipient by their own order: the phishing screen's soft
+        // rules never hold it (AGL-3356).
+        owedFor: 'order'
+    }));
+    // Cost meter (AGL-1438), as every transactional store email.
+    await meterHostEmail(ref.hostId);
+}
+/**
+ * Sends one order text. A receipt goes at once — the buyer is at the counter
+ * or the checkout waiting for it. Every later moment (shipped, delivered,
+ * refunded, canceled) can fire at any hour, from a carrier scan or a late
+ * packing shift, so it asks the provider to keep quiet hours in the STORE's
+ * zone: the best stand-in the platform has for a buyer whose own zone it was
+ * never told, and right for the local and regional stores most texts come
+ * from. Held texts arrive at 8 AM there.
+ */ async function deliverSms(ref, to, message, context, quiet) {
+    const sms = pluginSmsMessaging();
+    if (!(sms == null ? void 0 : sms.isConfigured())) return {
+        refused: 'Text messages are not configured'
+    };
+    let timeZone = null;
+    if (quiet) {
+        var _ref;
+        const owner = await getOrgForHost(ref.hostId).catch(()=>null);
+        timeZone = resolveSiteTimeZone((_ref = owner == null ? void 0 : owner.org) != null ? _ref : null, quiet.host);
+    }
+    const outcome = await sms.send(_extends({
+        to,
+        body: message.sms,
+        hostId: ref.hostId,
+        purpose: 'transactional',
+        context
+    }, timeZone ? {
+        quietHours: {
+            timeZone
+        }
+    } : {}));
+    if (outcome.status !== 'sent') return {
+        refused: outcome.status
+    };
+    return _extends({
+        refused: null
+    }, outcome.scheduledForMs ? {
+        scheduledForMs: outcome.scheduledForMs
+    } : {});
+}
+/** Absolute download links for a receipt's digital lines. */ function downloadLinksFor(store, ref, order) {
+    var _order_lineItems;
+    const origin = Aglyn.hostPublicOrigin({
+        cname: typeof store.host['cname'] === 'string' ? store.host['cname'] : null,
+        subdomain: typeof store.host['subdomain'] === 'string' ? store.host['subdomain'] : null
+    });
+    const digital = ((_order_lineItems = order.lineItems) != null ? _order_lineItems : []).filter((line)=>line.productType === 'digital');
+    if (!origin || !digital.length) return {};
+    let token;
+    try {
+        token = mintDownloadToken(ref.hostId, ref.orderId);
+    } catch (unused) {
+        return {};
+    }
+    return Object.fromEntries(digital.map((line)=>[
+            line.productId,
+            `${origin}/api/commerce/download?hostId=${encodeURIComponent(ref.hostId)}` + `&orderId=${encodeURIComponent(ref.orderId)}` + `&productId=${encodeURIComponent(line.productId)}&token=${token}`
+        ]));
+}
+async function readOrder(firestore, ref) {
+    var _snapshot_data;
+    const orderRef = firestore.collection('hosts').doc(ref.hostId).collection('orders').doc(ref.orderId);
+    const snapshot = await orderRef.get();
+    return {
+        orderRef,
+        order: snapshot.exists ? CommerceModel.liftLegacyOrder((_snapshot_data = snapshot.data()) != null ? _snapshot_data : {}) : null
+    };
+}
+function emailOf(value) {
+    const email = String(value != null ? value : '').trim();
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) ? email : '';
+}
+/**
+ * Tells the buyer about one moment in their order's life, once. See the
+ * module header. Never throws.
+ */ export async function notifyOrderBuyer(ref, event, options = {}) {
+    try {
+        var _options_firestore, _resolveHostToken, _store_settings_receiptFooter, _order_customerPhone;
+        var _pluginSmsMessaging;
+        if (!ref.hostId || !ref.orderId) return {
+            outcome: 'no_such_order'
+        };
+        const firestore = (_options_firestore = options.firestore) != null ? _options_firestore : firebaseAdmin.app().firestore();
+        const store = await readStore(firestore, ref.hostId);
+        const toggles = store.settings['buyerNotifications'];
+        if (!CommerceModel.buyerNotificationEnabled(toggles, event)) {
+            return {
+                outcome: 'disabled'
+            };
+        }
+        const { orderRef, order } = await readOrder(firestore, ref);
+        if (!order) return {
+            outcome: 'no_such_order'
+        };
+        const message = composeOrderBuyerMessage({
+            event,
+            order,
+            orderId: ref.orderId,
+            businessName: String((_resolveHostToken = resolveHostToken('businessName', store.host)) != null ? _resolveHostToken : ''),
+            currency: store.currency,
+            statusUrl: statusLink(store, ref),
+            receiptFooter: String((_store_settings_receiptFooter = store.settings['receiptFooter']) != null ? _store_settings_receiptFooter : ''),
+            downloadLinks: event === 'receipt' ? downloadLinksFor(store, ref, order) : undefined,
+            options
+        });
+        if (!message) return {
+            outcome: 'not_applicable'
+        };
+        const email = emailOf(order.customerEmail) || emailOf(options.email);
+        const phone = String((_order_customerPhone = order.customerPhone) != null ? _order_customerPhone : '').trim();
+        const targets = [];
+        if (email && isEmailConfigured()) targets.push({
+            channel: 'email',
+            to: email
+        });
+        if (phone && CommerceModel.buyerNotificationEnabled(toggles, 'texts') && ((_pluginSmsMessaging = pluginSmsMessaging()) == null ? void 0 : _pluginSmsMessaging.isConfigured())) {
+            targets.push({
+                channel: 'sms',
+                to: phone
+            });
+        }
+        if (!targets.length) return {
+            outcome: 'no_recipient'
+        };
+        const channels = [];
+        for (const target of targets){
+            const marker = CommerceModel.buyerNotificationMarker(event, message.occurrence, target.channel);
+            const claimed = await claimMessage(firestore, orderRef, marker, target.channel).catch((error)=>{
+                console.error('[order-notifications] claim failed', marker, error);
+                return false;
+            });
+            if (!claimed) {
+                channels.push({
+                    channel: target.channel,
+                    outcome: 'already'
+                });
+                continue;
+            }
+            const context = message.emailKey;
+            let held = null;
+            try {
+                if (target.channel === 'email') {
+                    await deliverEmail(store, ref, target.to, message, context);
+                } else {
+                    var _sent_scheduledForMs;
+                    const sent = await deliverSms(ref, target.to, message, context, event === 'receipt' ? null : {
+                        host: store.host
+                    });
+                    if (sent.refused) throw new Error(sent.refused);
+                    held = (_sent_scheduledForMs = sent.scheduledForMs) != null ? _sent_scheduledForMs : null;
+                }
+                await settleMessage(firestore, orderRef, marker, target.channel, held ? `${message.timelineDetail} (held for the morning)` : message.timelineDetail);
+                channels.push({
+                    channel: target.channel,
+                    outcome: 'sent'
+                });
+            } catch (error) {
+                await releaseMessage(orderRef, marker);
+                console.error('[order-notifications] send failed', {
+                    hostId: ref.hostId,
+                    orderId: ref.orderId,
+                    event,
+                    channel: target.channel,
+                    error
+                });
+                channels.push({
+                    channel: target.channel,
+                    outcome: 'failed',
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        return {
+            outcome: 'handled',
+            channels
+        };
+    } catch (error) {
+        console.error('[order-notifications] notify failed', ref, event, error);
+        return {
+            outcome: 'handled',
+            channels: []
+        };
+    }
+}
+/**
+ * Sends the receipt again, on the merchant's say-so, to the address or number
+ * they gave (AGL-3610) — the order dialog's "Resend receipt".
+ *
+ * NOT idempotent, on purpose: a resend IS the second send. The route in front
+ * of it is rate-limited instead, and the send is recorded on the timeline so
+ * the merchant can see it went. It does not consult the store's moment
+ * switches either — a merchant who turned automatic receipts off can still
+ * hand one to a customer who asks.
+ */ export async function sendOrderReceipt(ref, input) {
+    try {
+        var _input_firestore, _resolveHostToken, _store_settings_receiptFooter;
+        const firestore = (_input_firestore = input.firestore) != null ? _input_firestore : firebaseAdmin.app().firestore();
+        const { orderRef, order } = await readOrder(firestore, ref);
+        if (!order) return {
+            outcome: 'no_such_order'
+        };
+        if (input.channel === 'email') {
+            if (!isEmailConfigured()) return {
+                outcome: 'not_configured'
+            };
+            if (!emailOf(input.to)) return {
+                outcome: 'invalid_recipient'
+            };
+        } else {
+            var _pluginSmsMessaging;
+            if (!((_pluginSmsMessaging = pluginSmsMessaging()) == null ? void 0 : _pluginSmsMessaging.isConfigured())) {
+                return {
+                    outcome: 'not_configured'
+                };
+            }
+            if (!Aglyn.normalizePhone(input.to)) {
+                return {
+                    outcome: 'invalid_recipient'
+                };
+            }
+        }
+        const store = await readStore(firestore, ref.hostId);
+        const message = composeOrderBuyerMessage({
+            event: 'receipt',
+            order,
+            orderId: ref.orderId,
+            businessName: String((_resolveHostToken = resolveHostToken('businessName', store.host)) != null ? _resolveHostToken : ''),
+            currency: store.currency,
+            statusUrl: statusLink(store, ref),
+            receiptFooter: String((_store_settings_receiptFooter = store.settings['receiptFooter']) != null ? _store_settings_receiptFooter : ''),
+            downloadLinks: downloadLinksFor(store, ref, order)
+        });
+        if (!message) return {
+            outcome: 'failed',
+            error: 'Nothing to send'
+        };
+        if (input.channel === 'email') {
+            await deliverEmail(store, ref, emailOf(input.to), message, 'order-receipt');
+        } else {
+            const sent = await deliverSms(ref, input.to, message, 'order-receipt', null);
+            if (sent.refused) return {
+                outcome: 'failed',
+                error: sent.refused
+            };
+        }
+        await settleMessage(firestore, orderRef, null, input.channel, 'Receipt re-sent');
+        return {
+            outcome: 'sent',
+            channel: input.channel
+        };
+    } catch (error) {
+        console.error('[order-notifications] receipt send failed', ref, error);
+        return {
+            outcome: 'failed',
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * What the online receipt sends needs from this module (AGL-3610): whether
+ * the store left receipts on, and the `order.number` / `order.statusUrl`
+ * tokens. The cart and buy-now receipts compose their own summary (license
+ * keys and download links built from the Stripe session) inside the
+ * webhook's redelivery guard, so they ask here rather than route through
+ * {@link notifyOrderBuyer}.
+ */ export async function onlineReceiptExtras(hostId, orderId, firestore = firebaseAdmin.app().firestore()) {
+    try {
+        const store = await readStore(firestore, hostId);
+        const { order } = await readOrder(firestore, {
+            hostId,
+            orderId
+        });
+        return {
+            enabled: CommerceModel.buyerNotificationEnabled(store.settings['buyerNotifications'], 'receipt'),
+            tokens: {
+                'order.number': CommerceModel.formatOrderNumber(order != null ? order : {}, orderId),
+                'order.statusUrl': statusLink(store, {
+                    hostId,
+                    orderId
+                })
+            }
+        };
+    } catch (error) {
+        console.error('[order-notifications] receipt extras failed', error);
+        return {
+            enabled: true,
+            tokens: {
+                'order.number': '',
+                'order.statusUrl': ''
+            }
+        };
+    }
+}
+
+//# sourceMappingURL=order-notifications.js.map