@commercelayer/agent-cli 0.8.0 → 1.0.0-dev.0

package/dist/orderRequest.js

@@ -1,141 +0,0 @@
-// An order request from an email or a message (orders create), checked before it is sent: the
-// same rules the API applies, so a request missing what only the human knows fails here, naming
-// the path. Nothing is ever made up: no placeholder names, phones or addresses.
-import { fail } from './output.js';
-export const MAX_ITEMS = 25;
-const KEYS = ['source', 'customer', 'ship_to', 'bill_to', 'items', 'notes', 'reference', 'language', 'place', 'force'];
-const ASK = 'Ask the human for it; never invent it.';
-const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-const bad = (path, what, hint = ASK) => fail('invalid_argument', `${path}: ${what}`, hint, path);
-/** A text field: absent is undefined; present, it is a non-empty string of at most max characters. */
-function text(o, key, path, opts = {}) {
-    const v = o[key];
-    if (v === undefined || v === null || (typeof v === 'string' && !v.trim())) {
-        if (opts.required)
-            bad(`${path}.${key}`, 'is missing.');
-        return undefined;
-    }
-    if (typeof v !== 'string' && typeof v !== 'number')
-        bad(`${path}.${key}`, `is ${JSON.stringify(v)}, not text.`, 'Give it as text.');
-    const s = String(v).trim();
-    // A dash or a question mark stands for "unknown": the human has to say it.
-    if (/^[-?.]+$/.test(s))
-        bad(`${path}.${key}`, `is "${s}", a placeholder.`);
-    if (s.length > (opts.max ?? 255))
-        bad(`${path}.${key}`, `is longer than ${opts.max ?? 255} characters.`, 'Shorten it.');
-    return s;
-}
-function unknownKeys(o, allowed, path) {
-    const extra = Object.keys(o).filter((k) => !allowed.includes(k));
-    if (extra.length)
-        bad(`${path ? `${path}.` : ''}${extra[0]}`, `is not a field${path ? ` of ${path}` : ''}.`, `The fields are ${allowed.join(', ')}.`);
-}
-function address(o, path, withNames) {
-    if (!isObj(o))
-        return bad(path, 'is missing: the address the order ships to.');
-    const fields = ['line_1', 'line_2', 'city', 'postal_code', 'region', 'country', 'phone', ...(withNames ? ['first_name', 'last_name', 'company'] : [])];
-    unknownKeys(o, fields, path);
-    const country = text(o, 'country', path, { required: true }).toUpperCase();
-    if (!/^[A-Z]{2}$/.test(country))
-        bad(`${path}.country`, `is "${country}", not an ISO 3166 country code.`, 'Give the two-letter code: IT, FR, US.');
-    const out = {
-        line_1: text(o, 'line_1', path, { required: true }),
-        line_2: text(o, 'line_2', path),
-        city: text(o, 'city', path, { required: true }),
-        postal_code: text(o, 'postal_code', path, { required: true, max: 20 }),
-        region: text(o, 'region', path, { max: 50 }),
-        country,
-        phone: text(o, 'phone', path, { max: 40 }),
-        ...(withNames ? { first_name: text(o, 'first_name', path), last_name: text(o, 'last_name', path), company: text(o, 'company', path) } : {}),
-    };
-    return Object.fromEntries(Object.entries(out).filter(([, v]) => v !== undefined));
-}
-/** The request, checked and trimmed; invalid_argument naming the path, or too_many_items. */
-export function checkOrderRequest(raw) {
-    if (!isObj(raw))
-        return bad('request', 'is not a set of fields.', `Give it as YAML or JSON with ${KEYS.join(', ')}.`);
-    unknownKeys(raw, KEYS, '');
-    if (!isObj(raw.customer))
-        bad('customer', 'is missing: who the order is for (email, first_name, last_name or company, phone).');
-    const c = raw.customer;
-    unknownKeys(c, ['email', 'first_name', 'last_name', 'company', 'phone'], 'customer');
-    const email = text(c, 'email', 'customer', { required: true });
-    if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email))
-        bad('customer.email', `is "${email}", not an email address.`);
-    const customer = { email, first_name: text(c, 'first_name', 'customer'), last_name: text(c, 'last_name', 'customer'), company: text(c, 'company', 'customer'), phone: text(c, 'phone', 'customer', { max: 40 }) };
-    if (!customer.company && !(customer.first_name && customer.last_name))
-        bad(customer.first_name ? 'customer.last_name' : 'customer.first_name', 'is missing: an order needs the first and last name, or a company.');
-    const ship_to = address(raw.ship_to, 'ship_to', false);
-    if (!customer.phone && !ship_to.phone)
-        bad('customer.phone', 'is missing: Commerce Layer needs a phone number for the shipping address.');
-    const bill_to = raw.bill_to === undefined || raw.bill_to === null ? undefined : address(raw.bill_to, 'bill_to', true);
-    if (!Array.isArray(raw.items) || raw.items.length === 0)
-        bad('items', 'is missing: at least one line, { sku, quantity } or { query, quantity }.', 'Give each line a sku, or the words that name the product as query.');
-    const list = raw.items;
-    if (list.length > MAX_ITEMS)
-        fail('too_many_items', `items: ${list.length} lines, more than the ${MAX_ITEMS} one order takes.`, `Split it into orders of at most ${MAX_ITEMS} lines, with the human.`, 'items');
-    const items = list.map((it, i) => {
-        const path = `items[${i}]`;
-        if (!isObj(it))
-            return bad(path, `is ${JSON.stringify(it)}, not { sku, quantity } or { query, quantity }.`, 'Give each line a sku or a query, and a quantity.');
-        unknownKeys(it, ['sku', 'query', 'quantity'], path);
-        const sku = text(it, 'sku', path, { max: 100 });
-        const query = text(it, 'query', path, { max: 200 });
-        if (!sku && !query)
-            bad(path, 'has neither sku nor query.', 'Give the sku, or the words that name the product as query.');
-        const q = it.quantity ?? 1;
-        if (typeof q !== 'number' || !Number.isInteger(q) || q < 1 || q > 10_000)
-            bad(`${path}.quantity`, `is ${JSON.stringify(q)}, not a whole number from 1 to 10,000.`, 'Give how many, as the message says; ask the human if it looks wrong.');
-        return { ...(sku ? { sku } : {}), ...(query ? { query } : {}), quantity: q };
-    });
-    // Required: it makes the request idempotent, so a message never makes two orders.
-    let source;
-    {
-        const how = 'Give where the order came from: --source email:<Message-ID> for an email, --source message:<id> for anything else (the chat message or form id), or source: { kind, id } in the request.';
-        if (raw.source === undefined || raw.source === null)
-            bad('source', 'is missing: where the order came from.', how);
-        if (!isObj(raw.source))
-            return bad('source', 'is not { kind, id }.', how);
-        const s = raw.source;
-        unknownKeys(s, ['kind', 'id', 'from', 'subject', 'received_at'], 'source');
-        const kind = text(s, 'kind', 'source', { required: true });
-        if (kind !== 'email' && kind !== 'message')
-            bad('source.kind', `is "${kind}", not email or message.`, 'Use email for an email, message for anything else (a chat, a form, a call).');
-        source = { kind: kind, id: text(s, 'id', 'source', { required: true }), from: text(s, 'from', 'source'), subject: text(s, 'subject', 'source', { max: 500 }), received_at: text(s, 'received_at', 'source', { max: 40 }) };
-        source = Object.fromEntries(Object.entries(source).filter(([, v]) => v !== undefined));
-    }
-    const language = text(raw, 'language', 'request', { max: 5 })?.toLowerCase();
-    if (language && !/^[a-z]{2}$/.test(language))
-        bad('language', `is "${language}", not an ISO 639-1 code.`, 'Give the two-letter code: en, it, fr.');
-    for (const k of ['place', 'force'])
-        if (raw[k] !== undefined && typeof raw[k] !== 'boolean')
-            bad(k, `is ${JSON.stringify(raw[k])}, not true or false.`, `Write ${k}: true or leave it out.`);
-    const out = {
-        source,
-        customer: Object.fromEntries(Object.entries(customer).filter(([, v]) => v !== undefined)),
-        ship_to,
-        ...(bill_to ? { bill_to } : {}),
-        items,
-        ...(text(raw, 'notes', 'request', { max: 1000 }) ? { notes: text(raw, 'notes', 'request', { max: 1000 }) } : {}),
-        ...(text(raw, 'reference', 'request') ? { reference: text(raw, 'reference', 'request') } : {}),
-        ...(language ? { language } : {}),
-        ...(raw.place === true ? { place: true } : {}),
-        ...(raw.force === true ? { force: true } : {}),
-    };
-    return out;
-}
-/** "SKU:3" → { sku, quantity }, "dark roast:2" → { query, quantity }; no ":<n>" is 1. */
-export function lineFlag(raw, kind) {
-    const m = raw.match(/^(.*?)(?::\s*(\d+))?$/s);
-    const value = m[1].trim();
-    if (!value)
-        fail('invalid_argument', `--${kind === 'sku' ? 'item' : 'query'} ${raw} names nothing.`, kind === 'sku' ? 'Use --item <sku>:<quantity>, for example --item ETH:3.' : 'Use --query "<words>:<quantity>", for example --query "dark roast:2".');
-    return { [kind]: value, quantity: m[2] === undefined ? 1 : Number(m[2]) };
-}
-/** "email:<id>" or "message:<id>": the kind is everything before the first colon. */
-export function sourceFlag(raw) {
-    const i = raw.indexOf(':');
-    if (i < 1 || !raw.slice(i + 1).trim())
-        fail('invalid_argument', `--source ${raw} is not kind:id.`, 'Use --source email:<Message-ID> for an email, --source message:<id> for anything else.');
-    return { kind: raw.slice(0, i), id: raw.slice(i + 1).trim() };
-}

package/dist/output.js

@@ -1,39 +0,0 @@
-// Everything the CLI says is JSON on stdout: one object per run, pretty-printed.
-// A failure is { error: { code, message, hint } } with exit code 1. The hint is
-// the fix: an agent reads it and acts on it before trying anything else.
-// A command that waits (apply) writes progress to stderr, one JSON object per line.
-// Warnings the API sends about the CLI itself (cli_outdated) go into whatever is printed.
-export class CliError extends Error {
-    code;
-    hint;
-    path;
-    constructor(code, message, hint, 
-    /** The field of a request the error is about: customer.phone, items[0].quantity. */
-    path) {
-        super(message);
-        this.code = code;
-        this.hint = hint;
-        this.path = path;
-    }
-}
-export function fail(code, message, hint, path) {
-    throw new CliError(code, message, hint, path);
-}
-export function progress(data) {
-    process.stderr.write(JSON.stringify(data) + '\n');
-}
-const notices = [];
-/** Keep a warning to print with the result, once per code. */
-export function notice(n) {
-    if (!notices.some((x) => x.code === n.code))
-        notices.push(n);
-}
-export function print(data) {
-    let out = data;
-    if (notices.length && data && typeof data === 'object' && !Array.isArray(data)) {
-        const own = data.warnings;
-        // A command's own warnings are strings or objects; the API's are added after them.
-        out = { ...data, warnings: [...(Array.isArray(own) ? own : own === undefined ? [] : [own]), ...notices] };
-    }
-    process.stdout.write(JSON.stringify(out, null, 2) + '\n');
-}

package/dist/products.js

@@ -1,151 +0,0 @@
-// The catalog can be large, so it lives in files under .commercelayer/products/
-// next to (or instead of) the products list in store.yml. Every *.yml file is a
-// list of products in the store.yml shape; every *.csv file is one product per
-// row. All files are merged by sku, and errors name the file they come from.
-import fs from 'node:fs';
-import path from 'node:path';
-import YAML from 'yaml';
-import { paths } from './files.js';
-import { fail } from './output.js';
-import { setPlain, setTranslated, translatedColumn, translationColumns, TRANSLATED } from './languages.js';
-/** The fixed CSV columns; name_<ll>, description_<ll> and category_<ll> are translations; any other column named by an ISO 4217 code is a price. */
-export const CSV_COLUMNS = ['sku', 'name', 'description', 'image_url', 'category'];
-/** The product files, in a stable order. */
-export function productFiles() {
-    if (!fs.existsSync(paths.products))
-        return [];
-    return fs
-        .readdirSync(paths.products)
-        .filter((f) => /\.(ya?ml|csv)$/i.test(f))
-        .sort()
-        .map((f) => path.join(paths.products, f));
-}
-export function readProductFile(file) {
-    const text = fs.readFileSync(file, 'utf8');
-    const products = /\.csv$/i.test(file) ? fromCsv(file, text) : fromYaml(file, text);
-    return products.map((product) => ({ product, source: file }));
-}
-function fromYaml(file, text) {
-    let doc;
-    try {
-        doc = YAML.parse(text);
-    }
-    catch (e) {
-        const reason = e.message.split('\n')[0];
-        fail('invalid_yaml', `${file} is not valid YAML: ${reason}`, `Fix the YAML syntax in ${file} and run the command again.`);
-    }
-    if (doc === null || doc === undefined)
-        return [];
-    if (Array.isArray(doc))
-        return doc;
-    if (typeof doc === 'object') {
-        const obj = doc;
-        if (Array.isArray(obj.products))
-            return obj.products;
-        if ('sku' in obj)
-            return [obj];
-    }
-    fail('invalid_product', `${file} is not a list of products.`, 'A product file is a YAML list of products, each with sku, name and prices, in the same shape as products in store.yml.');
-}
-/** RFC 4180: quoted cells, doubled quotes, CRLF or LF. Blank lines are skipped. */
-export function parseCsv(text) {
-    const rows = [];
-    let row = [];
-    let cell = '';
-    let quoted = false;
-    for (let i = 0; i < text.length; i++) {
-        const ch = text[i];
-        if (quoted) {
-            if (ch === '"') {
-                if (text[i + 1] === '"') {
-                    cell += '"';
-                    i++;
-                }
-                else
-                    quoted = false;
-            }
-            else
-                cell += ch;
-        }
-        else if (ch === '"')
-            quoted = true;
-        else if (ch === ',') {
-            row.push(cell);
-            cell = '';
-        }
-        else if (ch === '\n' || ch === '\r') {
-            if (ch === '\r' && text[i + 1] === '\n')
-                i++;
-            row.push(cell);
-            rows.push(row);
-            row = [];
-            cell = '';
-        }
-        else
-            cell += ch;
-    }
-    if (cell !== '' || row.length) {
-        row.push(cell);
-        rows.push(row);
-    }
-    return rows.filter((r) => !(r.length === 1 && r[0].trim() === ''));
-}
-function fromCsv(file, text) {
-    const rows = parseCsv(text.replace(/^/, ''));
-    if (rows.length === 0)
-        return [];
-    const header = rows[0].map((h) => h.trim());
-    const columns = header.map((h) => {
-        const lower = h.toLowerCase();
-        if (CSV_COLUMNS.includes(lower))
-            return { field: lower };
-        const t = translatedColumn(h);
-        if (t)
-            return { translated: t.field, language: t.language };
-        if (/^[A-Z]{3}$/.test(h))
-            return { currency: h };
-        const why = lower === 'stock' ? 'Stock is not part of the catalog: inventory is tracked live in Commerce Layer. ' : '';
-        fail('invalid_product', `${file} has a column "${h}" that is not a product field.`, `${why}CSV columns are ${CSV_COLUMNS.join(', ')}, name_<ll>, description_<ll> and category_<ll> for other languages (name_it), and one column per currency with the price, named by its ISO 4217 code (EUR, USD, ...). Remove or rename the column.`);
-    });
-    if (!columns.some((c) => 'field' in c && c.field === 'sku'))
-        fail('invalid_product', `${file} has no sku column.`, `The first line of a product CSV names its columns: ${CSV_COLUMNS.join(', ')} and one per currency.`);
-    const products = [];
-    rows.slice(1).forEach((cells, i) => {
-        const line = `${file}:${i + 2}`;
-        const product = { sku: '', name: '', prices: {} };
-        columns.forEach((col, j) => {
-            const value = (cells[j] ?? '').trim();
-            if (value === '')
-                return;
-            if ('currency' in col) {
-                const price = Number(value);
-                if (!Number.isFinite(price))
-                    fail('invalid_product', `${line}: ${col.currency} price "${value}" is not a number.`, 'Write prices as plain decimals, such as 14.50, with no currency sign or thousands separator.');
-                product.prices[col.currency] = price;
-            }
-            else if ('translated' in col)
-                setTranslated(product, col.translated, col.language, value);
-            else if (TRANSLATED.includes(col.field))
-                setPlain(product, col.field, value);
-            else
-                product[col.field] = value;
-        });
-        products.push(product);
-    });
-    return products;
-}
-const csvCell = (v) => {
-    const t = v === undefined ? '' : String(v);
-    return /[",\r\n]/.test(t) ? `"${t.replace(/"/g, '""')}"` : t;
-};
-/** Products as CSV in the shape fromCsv reads: the fixed columns, the translations, then one per currency, rows by sku. Same products, same bytes. */
-export function toCsv(products) {
-    const currencies = [...new Set(products.flatMap((p) => Object.keys(p.prices ?? {})))].sort();
-    const translated = translationColumns(products.map((p) => p.translations));
-    const rows = [...products].sort((a, b) => (a.sku < b.sku ? -1 : a.sku > b.sku ? 1 : 0));
-    const lines = [[...CSV_COLUMNS, ...translated, ...currencies].join(',')];
-    const translation = (p, column) => p.translations?.[column.slice(-2)]?.[column.slice(0, -3)];
-    for (const p of rows)
-        lines.push([...CSV_COLUMNS.map((c) => csvCell(p[c])), ...translated.map((c) => csvCell(translation(p, c))), ...currencies.map((c) => csvCell(p.prices?.[c]))].join(','));
-    return lines.join('\n') + '\n';
-}

package/dist/promotions.js

@@ -1,291 +0,0 @@
-// promotions: in store.yml. The CLI validates the YAML sugar (single-key rules and actions,
-// categories, date-only days) and sends one normalized object per promotion in PUT /resources;
-// the API maps each to Commerce Layer promotions. Amounts stay in major units, like prices;
-// flex rules pass through as written (Rules Engine syntax, cents).
-import { fail } from './output.js';
-/** Commerce Layer needs both dates: without them the promotion runs from 2000 to 2100. */
-export const DEFAULT_STARTS = '2000-01-01T00:00:00Z';
-export const DEFAULT_ENDS = '2100-01-01T00:00:00Z';
-/** Promotions without a coupon that can be active at once: Commerce Layer's limit. */
-export const ACTIVE_LIMIT = 10;
-const KEYS = ['id', 'name', 'market', 'starts', 'ends', 'limit', 'priority', 'exclusive', 'enabled', 'rules', 'actions', 'flex'];
-const RULES = ['coupon', 'order_amount', 'skus', 'category'];
-const ACTIONS = ['percentage', 'fixed_amount', 'free_shipping', 'fixed_price', 'free_gift', 'buy_x_pay_y'];
-const SHAPE_HINT = 'See the promotions skill for the shape: https://commercelayer.ai/skills/promotions.md';
-const isObj = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
-const isNum = (v) => typeof v === 'number' && Number.isFinite(v);
-const isInt = (v, min) => Number.isInteger(v) && v >= min;
-const list = (v) => (Array.isArray(v) ? v : [v]);
-/** A date or a date-time, as ISO UTC. A bare day starts at 00:00:00Z and ends at 23:59:59Z. */
-export function isoDate(v, end, bad) {
-    const s = v instanceof Date ? v.toISOString().replace(/\.000Z$/, 'Z') : String(v);
-    const hint = 'Write a day, 2026-12-01, or a time in UTC, 2026-12-01T09:00:00Z.';
-    if (/^\d{4}-\d{2}-\d{2}$/.test(s)) {
-        if (Number.isNaN(Date.parse(s)))
-            bad(`"${s}" is not a date.`, hint);
-        return `${s}T${end ? '23:59:59' : '00:00:00'}Z`;
-    }
-    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})$/.test(s) || Number.isNaN(Date.parse(s)))
-        bad(`"${s}" is not a date.`, hint);
-    return new Date(s).toISOString().replace(/\.000Z$/, 'Z');
-}
-/**
- * The normalized shape (what list and show print) back to the YAML shorthand, so a promotion
- * read with show can be edited and sent to update: rules as an object, actions with a type.
- */
-function fromListed(p) {
-    const out = { ...p };
-    if (isObj(p.rules)) {
-        const r = p.rules;
-        out.rules = [
-            ...(r.coupons !== undefined ? [{ coupon: r.coupons }] : []),
-            ...(r.order_amount !== undefined ? [{ order_amount: r.order_amount }] : []),
-            ...(r.skus !== undefined ? [{ skus: r.skus }] : []),
-            ...Object.keys(r).filter((k) => !['coupons', 'order_amount', 'skus'].includes(k)).map((k) => ({ [k]: r[k] })),
-        ];
-    }
-    if (Array.isArray(p.actions)) {
-        out.actions = p.actions.map((a) => {
-            if (!isObj(a) || typeof a.type !== 'string')
-                return a;
-            const { type, ...rest } = a;
-            if (type === 'free_shipping')
-                return 'free_shipping';
-            if (type === 'percentage' || type === 'fixed_amount') {
-                const { value, ...targets } = rest;
-                return { [type]: value, ...targets };
-            }
-            return { [type]: rest };
-        });
-    }
-    return out;
-}
-/**
- * Validate one promotion spec (YAML or JSON, as given to promotions create or update) and
- * normalize it to the wire shape, or fail invalid_promotion naming the path inside the spec.
- * Categories become their products' skus as they are now, from store.yml.
- */
-export function checkPromotion(raw, markets, products) {
-    const skus = new Set(products.map((p) => p.sku));
-    const currencies = new Set(markets.map((m) => m.currency));
-    const at = 'promotion';
-    const bad = (msg, hint, path = at) => fail('invalid_promotion', `${path}: ${msg}`, hint);
-    {
-        const p = raw;
-        if (!isObj(p))
-            bad('is not a map.', `A promotion is a map with id, rules and actions. ${SHAPE_HINT}`);
-        const pr = fromListed(p);
-        if (typeof pr.id !== 'string' || !/^[a-z0-9][a-z0-9-]{0,62}$/.test(pr.id))
-            bad(`id is ${pr.id === undefined ? 'missing' : `"${String(pr.id)}"`}.`, 'Give the promotion an id of lowercase letters, digits and dashes, such as welcome10: the handle for show, update, enable, disable and delete.');
-        const id = pr.id;
-        for (const k of Object.keys(pr))
-            if (!KEYS.includes(k))
-                bad(`unknown key ${k}.`, `A promotion's keys are ${KEYS.join(', ')}.`);
-        const promo = { id, name: pr.name === undefined ? id : String(pr.name), starts: DEFAULT_STARTS, ends: DEFAULT_ENDS, exclusive: false, enabled: true };
-        if (!promo.name.trim() || promo.name.length > 255)
-            bad('name is empty or longer than 255 characters.', 'Write a short name the human will recognize in the dashboard.');
-        let currency;
-        if (pr.market !== undefined) {
-            const m = markets.find((x) => x.code === pr.market);
-            if (!m)
-                bad(`market ${String(pr.market)} is not in markets.`, `Use the code of one of the store's markets: ${markets.map((x) => x.code).join(', ')}.`);
-            promo.market = m.code;
-            currency = m.currency;
-        }
-        if (pr.starts !== undefined)
-            promo.starts = isoDate(pr.starts, false, (m, h) => bad(`starts ${m}`, h));
-        if (pr.ends !== undefined)
-            promo.ends = isoDate(pr.ends, true, (m, h) => bad(`ends ${m}`, h));
-        if (Date.parse(promo.ends) <= Date.parse(promo.starts))
-            bad('ends is not after starts.', 'Make the end date later than the start date.');
-        if (pr.limit !== undefined) {
-            if (!isInt(pr.limit, 1))
-                bad(`limit is ${String(pr.limit)}.`, 'limit is the total number of uses, a whole number of 1 or more.');
-            promo.limit = pr.limit;
-        }
-        if (pr.priority !== undefined) {
-            if (!isInt(pr.priority, 1))
-                bad(`priority is ${String(pr.priority)}.`, 'priority is a whole number of 1 or more; the lowest runs first.');
-            promo.priority = pr.priority;
-        }
-        for (const k of ['exclusive', 'enabled']) {
-            if (pr[k] !== undefined && typeof pr[k] !== 'boolean')
-                bad(`${k} is ${String(pr[k])}.`, `${k} is true or false.`);
-            if (pr[k] !== undefined)
-                promo[k] = pr[k];
-        }
-        if (pr.flex !== undefined) {
-            if (pr.rules !== undefined || pr.actions !== undefined)
-                bad('has flex and rules or actions.', 'A flex promotion keeps its rules and actions inside flex: remove the other rules and actions, or remove flex.');
-            const f = pr.flex;
-            if (!isObj(f) || !Array.isArray(f.rules) || f.rules.length === 0)
-                bad('flex has no rules.', 'Write flex: { rules: [...] }, each rule with conditions and actions. See docs.commercelayer.io/rules-engine.');
-            f.rules.forEach((r, j) => {
-                const path = `flex.rules[${j}]`;
-                if (!isObj(r) || !Array.isArray(r.conditions) || !r.conditions.length || !Array.isArray(r.actions) || !r.actions.length)
-                    bad('needs a list of conditions and a list of actions.', 'Each flex rule has conditions (field, matcher, value) and actions (type, selector, value).', path);
-            });
-            promo.flex = f;
-            return promo;
-        }
-        // Rules: a list of single-key maps; none means every order.
-        const rules = {};
-        let ruleSkus;
-        const seen = new Set();
-        const resolve = (v, kind, path) => {
-            if (kind === 'category') {
-                const name = String(v).split('>').map((s) => s.trim()).filter(Boolean).join(' > ');
-                const found = products.filter((x) => x.category === name || x.category?.startsWith(`${name} > `)).map((x) => x.sku);
-                if (!name || !found.length)
-                    bad(`no product is in category "${String(v)}".`, `Use a category of the store's products, written as in the products: ${[...new Set(products.map((x) => x.category).filter(Boolean))].join(', ') || 'none has a category yet'}.`, path);
-                return found.sort();
-            }
-            const l = list(v).map(String);
-            if (!l.length)
-                bad('skus is empty.', 'List one or more SKUs.', path);
-            for (const s of l)
-                if (!skus.has(s))
-                    bad(`${s} is not a product.`, 'Use SKUs of the store\'s products.', path);
-            return [...new Set(l)].sort();
-        };
-        const rawRules = pr.rules === undefined ? [] : pr.rules;
-        if (!Array.isArray(rawRules))
-            bad('rules is not a list.', `Write rules as a list: rules: [{ coupon: CODE }]. ${SHAPE_HINT}`);
-        rawRules.forEach((r, j) => {
-            const path = `rules[${j}]`;
-            if (!isObj(r) || Object.keys(r).length !== 1)
-                bad('is not a single rule.', `Each rule is one of ${RULES.join(', ')}, written as a one-key map: { coupon: CODE }.`, path);
-            const [k, v] = Object.entries(r)[0];
-            if (!RULES.includes(k))
-                bad(`unknown rule ${k}.`, `Rules are ${RULES.join(', ')}. For anything else, write a flex promotion.`, path);
-            const kind = k === 'category' ? 'skus' : k;
-            if (seen.has(kind))
-                bad(`has two ${kind === 'skus' ? 'skus or category' : k} rules.`, kind === 'skus' ? 'Use skus or category once per promotion: list every SKU in one rule, or make two promotions.' : `Use one ${k} rule per promotion; a coupon rule takes a list of codes.`, path);
-            seen.add(kind);
-            if (k === 'coupon') {
-                const l = list(v).map(String);
-                for (const c of l) {
-                    if (!/^[A-Za-z0-9_-]{8,40}$/.test(c))
-                        bad(`coupon "${c}" is not 8 to 40 letters, digits, - or _.`, 'Commerce Layer codes have 8 to 40 characters: WELCOME10, not WELCOME.', path);
-                }
-                if (!l.length)
-                    bad('coupon has no code.', 'Write coupon: CODE, or a list of codes.', path);
-                if (new Set(l).size > 20)
-                    bad(`coupon has ${new Set(l).size} codes.`, 'A promotion takes at most 20 codes: split them across promotions.', path);
-                rules.coupons = [...new Set(l)];
-            }
-            else if (k === 'order_amount') {
-                if (isObj(v) && v.max !== undefined)
-                    bad('order_amount has a max.', 'Commerce Layer promotions match a minimum order amount only: remove max, or write a flex promotion.', path);
-                if (!isObj(v) || Object.keys(v).some((x) => x !== 'min') || !isNum(v.min) || v.min <= 0)
-                    bad('order_amount needs min, a positive amount.', 'Write order_amount: { min: 50 }, the minimum items total, in the market currency, in major units.', path);
-                rules.order_amount = { min: v.min };
-            }
-            else {
-                ruleSkus = resolve(v, k, path);
-                rules.skus = ruleSkus;
-            }
-        });
-        // Actions: one or more, a single-key map or the bare free_shipping.
-        if (!Array.isArray(pr.actions) || pr.actions.length === 0)
-            bad('has no actions.', `Add actions: what the promotion does, such as actions: [{ percentage: 10 }]. ${SHAPE_HINT}`);
-        const actions = [];
-        const types = new Set();
-        let needsCurrency = Boolean(rules.order_amount);
-        pr.actions.forEach((a, j) => {
-            const path = `actions[${j}]`;
-            const entry = a === 'free_shipping' ? { free_shipping: true } : a;
-            if (!isObj(entry))
-                bad('is not an action.', `Each action is one of ${ACTIONS.join(', ')}: { percentage: 10 }, or free_shipping.`, path);
-            const [k, v] = Object.entries(entry)[0] ?? [];
-            if (!ACTIONS.includes(k))
-                bad(`unknown action ${k ?? '(none)'}.`, `Actions are ${ACTIONS.join(', ')}. For anything else, write a flex promotion.`, path);
-            if (types.has(k))
-                bad(`has two ${k} actions.`, 'Use each action once per promotion.', path);
-            types.add(k);
-            const extra = Object.keys(entry).filter((x) => x !== k);
-            // Targets: skus or category next to the action, or inside its map; else the rule's.
-            const target = (o, required) => {
-                if (o.skus !== undefined && o.category !== undefined)
-                    bad('has skus and category.', 'Use one of them.', path);
-                if (o.skus !== undefined)
-                    return resolve(o.skus, 'skus', path);
-                if (o.category !== undefined)
-                    return resolve(o.category, 'category', path);
-                if (required && !ruleSkus)
-                    bad(`${k} needs the SKUs it applies to.`, `Add skus: [...] or category: ... to the action, or a skus or category rule.`, path);
-                return ruleSkus;
-            };
-            const only = (o, allowed) => {
-                for (const x of Object.keys(o))
-                    if (!allowed.includes(x))
-                        bad(`unknown key ${x} in ${k}.`, `${k} takes ${allowed.join(', ')}.`, path);
-            };
-            if (k === 'percentage') {
-                only(entry, ['percentage', 'skus', 'category']);
-                if (!isInt(v, 1) || v > 100)
-                    bad(`percentage is ${String(v)}.`, 'percentage is a whole number from 1 to 100: 10 is 10% off. To make shipping free, use free_shipping.', path);
-                const t = target(entry, false);
-                actions.push({ type: 'percentage', value: v, ...(t ? { skus: t } : {}) });
-            }
-            else if (k === 'fixed_amount') {
-                only(entry, ['fixed_amount']);
-                if (!isNum(v) || v <= 0)
-                    bad(`fixed_amount is ${String(v)}.`, 'fixed_amount is the amount off the order, in major units: 5 is 5 euros.', path);
-                actions.push({ type: 'fixed_amount', value: v });
-                needsCurrency = true;
-            }
-            else if (k === 'free_shipping') {
-                if (extra.length || (v !== true && v !== null && !(isObj(v) && !Object.keys(v).length)))
-                    bad('free_shipping takes no settings.', 'Write free_shipping on its own.', path);
-                actions.push({ type: 'free_shipping' });
-            }
-            else {
-                if (extra.length)
-                    bad(`${k} has keys next to it: ${extra.join(', ')}.`, `Put them inside: ${k}: { ... }.`, path);
-                if (!isObj(v))
-                    bad(`${k} is not a map.`, SHAPE_HINT, path);
-                const o = v;
-                if (k === 'fixed_price') {
-                    only(o, ['price', 'skus', 'category']);
-                    if (!isNum(o.price) || o.price <= 0)
-                        bad(`fixed_price.price is ${String(o.price)}.`, 'price is the price the SKUs sell at, in major units: 9.90.', path);
-                    actions.push({ type: 'fixed_price', price: o.price, skus: target(o, true) });
-                    needsCurrency = true;
-                }
-                else if (k === 'free_gift') {
-                    only(o, ['skus', 'category', 'quantity']);
-                    if (o.skus === undefined && o.category === undefined)
-                        bad('free_gift needs the SKUs given away.', 'Write free_gift: { skus: [GIFT-SKU], quantity: 1 }.', path);
-                    if (o.quantity !== undefined && !isInt(o.quantity, 1))
-                        bad(`free_gift.quantity is ${String(o.quantity)}.`, 'quantity is a whole number of 1 or more.', path);
-                    const gifts = target(o, true);
-                    if (gifts.length > 25)
-                        bad(`free_gift has ${gifts.length} skus.`, 'A free gift takes at most 25 SKUs: narrow the list or the category.', path);
-                    actions.push({ type: 'free_gift', skus: gifts, quantity: o.quantity ?? 1 });
-                }
-                else {
-                    only(o, ['x', 'y', 'cheapest_free', 'skus', 'category']);
-                    if (!isInt(o.x, 2) || !isInt(o.y, 1) || o.y >= o.x)
-                        bad(`buy_x_pay_y is x ${String(o.x)}, y ${String(o.y)}.`, 'x and y are whole numbers with x above y and y at least 1: { x: 3, y: 2 } is 3 for 2.', path);
-                    if (o.cheapest_free !== undefined && typeof o.cheapest_free !== 'boolean')
-                        bad('cheapest_free is not true or false.', 'cheapest_free is true or false.', path);
-                    actions.push({ type: 'buy_x_pay_y', x: o.x, y: o.y, cheapest_free: o.cheapest_free ?? false, skus: target(o, true) });
-                }
-            }
-        });
-        if (needsCurrency && !currency && currencies.size > 1)
-            bad('has an amount but no market, in a store with several currencies.', 'Set market: so the amount has a currency, or use a percentage.');
-        promo.rules = rules;
-        promo.actions = actions;
-        return promo;
-    }
-}
-/**
- * Commerce Layer promotions active without a coupon: each action of an enabled promotion that
- * has not ended is one (the API makes one per action). Commerce Layer applies at most 10.
- */
-export function activeWithoutCoupon(promotions, now = Date.now()) {
-    const live = promotions.filter((p) => p.enabled && !p.flex && !p.rules?.coupons && Date.parse(p.ends) > now);
-    return { count: live.reduce((n, p) => n + (p.actions?.length ?? 1), 0), ids: live.map((p) => p.id) };
-}