@lana-commerce/core 11.0.0

package/esm/json/mutator.js

@@ -0,0 +1,952 @@
+import { CommerceFileUploadAPI } from "./commerceFileUpload.js";
+import { request } from "./commerce.js";
+import { PromiseLimiter } from "../promiseLimit.js";
+import { uploadFileGeneric } from "../genericFile.js";
+import { generateUUID } from "../generateUUID.js";
+import { trace } from "..//trace.js";
+import { traverse } from "../traverse.js";
+import { uploadFileWebsocket } from "../fileWebsocket.js";
+function isUnresolvedID(id) {
+    return id.startsWith(":TMPID:");
+}
+function unID(kind) {
+    return `:TMPID:${kind}:${generateUUID()}`;
+}
+function extractUniqueUnresolvedIDs(obj) {
+    const allIDs = new Set();
+    traverse(obj, (_obj, _prop, value) => {
+        if (typeof value === "string" && isUnresolvedID(value)) {
+            allIDs.add(value);
+        }
+    });
+    return Array.from(allIDs.keys());
+}
+export class NullLogger {
+    line() { }
+    bar() {
+        return { start: () => { }, stop: () => { }, increment: () => { } };
+    }
+    tree() { }
+}
+function collectNextBatch(resolvedItems, queue) {
+    const out = {
+        collected: [],
+        remaining: [],
+    };
+    for (const q of queue) {
+        if (q.items.length === 0)
+            continue;
+        const itemsReady = q.items.map((item) => item.deps.every((dep) => resolvedItems.has(dep)));
+        const itemsReadyCount = itemsReady.reduce((count, b) => count + (b ? 1 : 0), 0);
+        if (itemsReadyCount === q.items.length) {
+            out.collected.push(q);
+        }
+        else if (itemsReadyCount > 0) {
+            // split batch
+            out.collected.push(q.extractItems((_item, idx) => itemsReady[idx]));
+            out.remaining.push(q);
+        }
+        else {
+            out.remaining.push(q);
+        }
+    }
+    return out;
+}
+function normalizeName(name) {
+    if (typeof name === "string") {
+        return { singular: name, plural: name };
+    }
+    else {
+        return name;
+    }
+}
+function plur(v) {
+    return {
+        singular: v.replace("(s)", ""),
+        plural: v.replace("(s)", "s"),
+    };
+}
+function formatName(name, n) {
+    return n === 1 ? name.singular : name.plural;
+}
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+function applyResolvedIDs(obj, resolvedIDs) {
+    traverse(obj, (obj, prop, value) => {
+        if (typeof value === "string" && isUnresolvedID(value)) {
+            const rid = resolvedIDs.get(value);
+            if (!rid)
+                throw new Error(`unresolved id: ${value}`);
+            obj[prop] = rid;
+        }
+    });
+    // important to do this after ID resolving
+    traverse(obj, (obj, prop, value) => {
+        if (value !== null && typeof value === "object" && value.__deferredJSONObject === true) {
+            obj[prop] = JSON.stringify(value.value);
+        }
+    });
+}
+function applyResolvedIDsToItems(items, resolvedIDs) {
+    for (const { item } of items) {
+        applyResolvedIDs(item, resolvedIDs);
+    }
+}
+// the type here is very evil, be sure to use this function only within the mutator context and for a specific need
+// e.g. as custom_fields[].value
+export function deferredJSONObject(value) {
+    return {
+        value,
+        __deferredJSONObject: true,
+    };
+}
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+const jsonify = (v) => JSON.stringify(v, null, 2);
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+function chunk(input, size) {
+    return input.reduce((arr, item, idx) => {
+        return idx % size === 0 ? [...arr, [item]] : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
+    }, []);
+}
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+function itemByItemProcessor(name, resolveItem) {
+    const normalizedName = normalizeName(name);
+    return async (ectx, ctx, items, resolvedIDs) => {
+        const resolveItemImpl = async (item) => {
+            const result = await ectx.enqueue(normalizedName, 1, () => resolveItem(ctx, item));
+            if (result === null)
+                return [item.id, ""];
+            if (!result)
+                throw new Error(`unsuccessful API call\nitem: ${jsonify(item)}`);
+            if (Array.isArray(result)) {
+                if (result.length !== 1)
+                    throw new Error(`unsuccessful API call\nitem: ${jsonify(item)}`);
+                return [item.id, result[0].id];
+            }
+            else {
+                return [item.id, result.id];
+            }
+        };
+        applyResolvedIDsToItems(items, resolvedIDs);
+        if (ectx.opts.sequential) {
+            const out = [];
+            for (const item of items) {
+                out.push(await resolveItemImpl(item));
+            }
+            return out;
+        }
+        else {
+            return Promise.all(items.map(resolveItemImpl));
+        }
+    };
+}
+function resultToIDMap(props, items, result) {
+    if (!result) {
+        throw new Error(`unsuccessful batch API call\nprops: ${jsonify(props)}\nitems: ${jsonify(items)}`);
+    }
+    if (items.length !== result.length) {
+        throw new Error(`mismatching number of items\nprops: ${jsonify(props)}\nitems: ${jsonify(items)}\nresult: ${jsonify(result)}`);
+    }
+    return items.map((item, idx) => [item.id, result[idx].id]);
+}
+function batchProcessor(name, perBatch, groupBy, resolveItems) {
+    const normalizedName = normalizeName(name);
+    return async (ectx, ctx, items, resolvedIDs) => {
+        applyResolvedIDsToItems(items, resolvedIDs);
+        // group items
+        const groupsMap = new Map();
+        for (const item of items) {
+            const key = groupBy(item.item);
+            let group = groupsMap.get(key);
+            if (!group) {
+                group = { props: item.item, items: [] };
+                groupsMap.set(key, group);
+            }
+            group.items.push(item);
+        }
+        const groups = Array.from(groupsMap.values());
+        let result = [];
+        if (ectx.opts.sequential) {
+            for (const { props, items } of groups) {
+                const r1 = [];
+                const batches = chunk(items, perBatch);
+                for (const items of batches) {
+                    const result = await ectx.enqueue(normalizedName, items.length, () => resolveItems(ctx, props, items));
+                    if (result === null)
+                        return [];
+                    r1.push(resultToIDMap(props, items, result));
+                }
+                result.push(r1);
+            }
+        }
+        else {
+            result = await Promise.all(groups.map(({ props, items }) => {
+                return Promise.all(chunk(items, perBatch).map(async (items) => {
+                    const result = await ectx.enqueue(normalizedName, items.length, () => resolveItems(ctx, props, items));
+                    if (result === null)
+                        return [];
+                    return resultToIDMap(props, items, result);
+                }));
+            }));
+        }
+        // flatten result
+        return result.reduce((a, b) => a.concat(b), []).reduce((a, b) => a.concat(b), []);
+    };
+}
+class StatsExecuteContext {
+    progressCallback;
+    stats;
+    opts;
+    limit;
+    constructor(name, opts, progressCallback) {
+        this.progressCallback = progressCallback;
+        this.opts = opts;
+        this.stats = { name, stats: new Map(), secondsElapsed: +new Date() };
+        this.limit = new PromiseLimiter(opts.sequential ? 1 : 20);
+    }
+    done() {
+        this.stats.secondsElapsed = (+new Date() - this.stats.secondsElapsed) / 1000;
+    }
+    async enqueue(name, quantity, f) {
+        const stats = this.stats.stats;
+        let s = stats.get(name);
+        if (!s) {
+            s = { apiCalls: 0, objects: 0, secondsElapsed: 0 };
+            stats.set(name, s);
+        }
+        const t0 = +new Date();
+        const result = await this.limit.run((tid) => {
+            return trace(tid, `${quantity} ${formatName(name, quantity)}`, () => f());
+        });
+        const t1 = +new Date();
+        s.secondsElapsed += (t1 - t0) / 1000;
+        s.apiCalls++;
+        s.objects += quantity;
+        this.progressCallback?.(quantity);
+        return result;
+    }
+}
+function batchShopIDAndReqCreator(batcher, name, desc, ep) {
+    return makeQueue(batcher, name, batchProcessor(desc, 30, (props) => props.shopID, (ctx, props, items) => {
+        return ep(ctx)
+            .shop_id(props.shopID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+        return uid;
+    });
+}
+function batchShopIDAndReqModifier(batcher, name, desc, ep) {
+    return makeQueue(batcher, name, batchProcessor(desc, 30, (props) => props.shopID, (ctx, props, items) => {
+        return ep(ctx)
+            .ids(items.map((v) => v.item.id))
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, id, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, req });
+    });
+}
+function batchShopIDAndReqAndLocaleModifier(batcher, name, desc, ep) {
+    return makeQueue(batcher, name, batchProcessor(desc, 30, (props) => `${props.shopID}:${props.locale}`, (ctx, props, items) => {
+        const lctx = { ...ctx, locale: props.locale };
+        return ep(lctx)
+            .ids(items.map((v) => v.item.id))
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, id, req, locale) => {
+        const uid = q.unID();
+        q.push(uid, { locale, shopID, id, req });
+    });
+}
+function batchShopIDAndIDDeletor(batcher, name, desc, ep) {
+    return makeQueue(batcher, name, batchProcessor(desc, 30, (props) => props.shopID, async (ctx, props, items) => {
+        await ep(ctx)
+            .ids(items.map((v) => v.id))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, id) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, req: null });
+    });
+}
+class GenericQueueItemCollection {
+    _name;
+    _processor;
+    _id;
+    _queue = [];
+    constructor(_name, _processor) {
+        this._name = _name;
+        this._processor = _processor;
+        this._id = generateUUID();
+    }
+    get id() {
+        return this._id;
+    }
+    get items() {
+        return this._queue;
+    }
+    get processor() {
+        return this._processor;
+    }
+    unID() {
+        return unID(this._name);
+    }
+    push(id, item) {
+        const deps = extractUniqueUnresolvedIDs(item);
+        this._queue.push({ id, deps, item });
+    }
+    extractItems(cond) {
+        const result = this._queue.reduce((accum, item, idx) => {
+            (cond(item, idx) ? accum.extracted : accum.remaining).push(item);
+            return accum;
+        }, { extracted: [], remaining: [] });
+        this._queue = result.remaining;
+        const c = new GenericQueueItemCollection(this._name, this._processor);
+        c._queue = result.extracted;
+        return c;
+    }
+}
+class Batch {
+    queues = new Map();
+    barrier;
+    get allQueues() {
+        const out = [];
+        this.queues.forEach((val) => {
+            out.push(val);
+        });
+        return out;
+    }
+    // Note that when processing multiple batches with cross batch dependencies (see barrier()), this
+    // function needs to be aware of previously resolved IDs, hence these are provided via argument.
+    topoSort(resolvedIDs) {
+        const out = [];
+        const resolvedItems = new Set(resolvedIDs);
+        let remaining = this.allQueues;
+        while (true) {
+            if (remaining.length === 0)
+                break;
+            const nextBatch = collectNextBatch(resolvedItems, remaining);
+            if (nextBatch.collected.length === 0) {
+                const items = [];
+                remaining.forEach((q) => {
+                    q.items.forEach((item) => {
+                        items.push(`${item.id}: ${item.deps.join(", ")}`);
+                    });
+                });
+                throw new Error(`unable to resolve dependencies, remaining items:\n${items.join("\n")}`);
+            }
+            for (const q of nextBatch.collected) {
+                for (const item of q.items) {
+                    resolvedItems.add(item.id);
+                }
+            }
+            out.push(nextBatch.collected);
+            remaining = nextBatch.remaining;
+        }
+        return out;
+    }
+    numberOfItems() {
+        let n = 0;
+        for (const q of this.allQueues) {
+            n += q.items.length;
+        }
+        return n;
+    }
+}
+function makeQueue(batcher, name, itemProcessor, f) {
+    return ((...args) => {
+        const b = batcher.currentBatch;
+        let q = b.queues.get(name);
+        if (!q) {
+            q = new GenericQueueItemCollection(name, itemProcessor);
+            b.queues.set(name, q);
+        }
+        return f(q, ...args);
+    });
+}
+export class Mutator {
+    batches = [new Batch()];
+    opts;
+    constructor(opts) {
+        this.opts = opts || {};
+    }
+    get currentBatch() {
+        const n = this.batches.length;
+        return this.batches[n - 1];
+    }
+    barrier(desc, data, func) {
+        if (desc && func) {
+            this.currentBatch.barrier = { desc, data, func };
+        }
+        this.batches.push(new Batch());
+    }
+    shop = makeQueue(this, "shop", itemByItemProcessor(plur("shop(s) created"), (ctx, { item }) => {
+        return request(ctx, `POST:shops.json`).data([item.req]).sendUnwrap();
+    }), (q, req) => {
+        const uid = q.unID();
+        q.push(uid, { req });
+        return uid;
+    });
+    shopModify = makeQueue(this, "shopModify", itemByItemProcessor(plur("shop(s) modified"), async (ctx, { item }) => {
+        await request(ctx, `POST:shops.json`).shop_id(item.shopID).data([item.req]).sendUnwrap();
+        return null;
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+    });
+    shopSettings = makeQueue(this, "shopSettings", itemByItemProcessor(plur("shop settings applied"), async (ctx, { item }) => {
+        await request(ctx, `POST:shops/settings.json`).shop_id(item.shopID).data(item.req).sendUnwrap();
+        return null;
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+    });
+    taxRule = batchShopIDAndReqCreator(this, "taxRule", plur("tax rule(s) created"), (ctx) => request(ctx, `POST:tax_rules.json`));
+    taxRuleModify = batchShopIDAndReqModifier(this, "taxRuleModify", plur("tax rule(s) modified"), (ctx) => request(ctx, `POST:tax_rules.json`));
+    taxRuleDelete = batchShopIDAndIDDeletor(this, "taxRuleDelete", plur("tax rule(s) deleted"), (ctx) => request(ctx, `DELETE:tax_rules.json`));
+    taxRulesAddDefault = makeQueue(this, "taxRulesAddDefault", itemByItemProcessor(plur("default tax rule(s) added"), async (ctx, { item }) => {
+        await request(ctx, `POST:tax_rules/add_default.json`).shop_id(item.shopID).country(item.country).sendUnwrap();
+        return null;
+    }), (q, shopID, country) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, country, req: null });
+    });
+    returnReason = batchShopIDAndReqCreator(this, "returnReason", plur("return reason(s) created"), (ctx) => request(ctx, `POST:return_reasons.json`));
+    returnReasonModify = batchShopIDAndReqModifier(this, "returnReasonModify", plur("return reason(s) modified"), (ctx) => request(ctx, `POST:return_reasons.json`));
+    returnReasonDelete = batchShopIDAndIDDeletor(this, "returnReasonDelete", plur("return reason(s) deleted"), (ctx) => request(ctx, `DELETE:return_reasons.json`));
+    returnReasonsAddDefault = makeQueue(this, "returnReasonsAddDefault", itemByItemProcessor(plur("default return reason(s) added"), async (ctx, { item }) => {
+        await request(ctx, `POST:return_reasons/add_default.json`).shop_id(item.shopID).sendUnwrap();
+        return null;
+    }), (q, shopID) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req: null });
+    });
+    returnInspectionsAddDefault = makeQueue(this, "returnInspectionsAddDefault", itemByItemProcessor(plur("default return inspection(s) added"), async (ctx, { item }) => {
+        await request(ctx, `POST:return_inspections/add_default.json`).shop_id(item.shopID).sendUnwrap();
+        return null;
+    }), (q, shopID) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req: null });
+    });
+    inventoryLocation = batchShopIDAndReqCreator(this, "inventoryLocation", plur("inventory location(s) created"), (ctx) => request(ctx, `POST:inventory_locations.json`));
+    inventoryLocationModify = batchShopIDAndReqAndLocaleModifier(this, "inventoryLocationModify", plur("inventory location(s) modified"), (ctx) => request(ctx, `POST:inventory_locations.json`));
+    gateway = makeQueue(this, "gateway", itemByItemProcessor(plur("gateway(s) created"), (ctx, { item }) => {
+        return request(ctx, `POST:gateways.json`).shop_id(item.shopID).data([item.req]).sendUnwrap();
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+        return uid;
+    });
+    gatewayModify = makeQueue(this, "gatewayModify", itemByItemProcessor(plur("gateway(s) modified"), (ctx, { item }) => {
+        const lctx = { ...ctx, locale: item.locale };
+        return request(lctx, `POST:gateways.json`).ids([item.id]).shop_id(item.shopID).data([item.req]).sendUnwrap();
+    }), (q, shopID, id, req, locale) => {
+        const uid = q.unID();
+        q.push(uid, { locale, shopID, id, req });
+    });
+    gatewayDelete = makeQueue(this, "gatewayDelete", itemByItemProcessor(plur("gateway(s) deleted"), async (ctx, { item }) => {
+        await request(ctx, `DELETE:gateways.json`).ids([item.id]).shop_id(item.shopID).sendUnwrap();
+        return null;
+    }), (q, shopID, id) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, req: null });
+    });
+    webhook = batchShopIDAndReqCreator(this, "webhook", plur("webhook(s) created"), (ctx) => request(ctx, `POST:webhooks.json`));
+    webhookModify = batchShopIDAndReqModifier(this, "webhookModify", plur("webhook(s) modified"), (ctx) => request(ctx, `POST:webhooks.json`));
+    webhookDelete = batchShopIDAndIDDeletor(this, "webhookDelete", plur("webhook(s) deleted"), (ctx) => request(ctx, `DELETE:webhooks.json`));
+    shippingProvider = batchShopIDAndReqCreator(this, "shippingProvider", plur("shipping provider(s) created"), (ctx) => request(ctx, `POST:shipping_providers.json`));
+    shippingProviderModify = batchShopIDAndReqAndLocaleModifier(this, "shippingProviderModify", plur("shipping provider(s) modified"), (ctx) => request(ctx, `POST:shipping_providers.json`));
+    shippingProviderDelete = batchShopIDAndIDDeletor(this, "shippingProviderDelete", plur("shipping provider(s) deleted"), (ctx) => request(ctx, `DELETE:shipping_providers.json`));
+    shippingRule = batchShopIDAndReqCreator(this, "shippingRule", plur("shipping rule(s) created"), (ctx) => request(ctx, `POST:shipping_rules.json`));
+    shippingRuleModify = batchShopIDAndReqModifier(this, "shippingRuleModify", plur("shipping rule(s) modified"), (ctx) => request(ctx, `POST:shipping_rules.json`));
+    shippingRuleDelete = batchShopIDAndIDDeletor(this, "shippingRuleDelete", plur("shipping rule(s) deleted"), (ctx) => request(ctx, `DELETE:shipping_rules.json`));
+    promotion = batchShopIDAndReqCreator(this, "promotion", plur("promotion(s) created"), (ctx) => request(ctx, `POST:promotions.json`));
+    promotionModify = batchShopIDAndReqModifier(this, "promotionModify", plur("promotion(s) modified"), (ctx) => request(ctx, `POST:promotions.json`));
+    promotionDelete = batchShopIDAndIDDeletor(this, "promotionDelete", plur("promotion(s) deleted"), (ctx) => request(ctx, `DELETE:promotions.json`));
+    coupon = makeQueue(this, "coupon", batchProcessor(plur("coupon(s) created"), 30, (props) => `${props.shopID}:${props.promotionID}`, (ctx, props, items) => {
+        return request(ctx, `POST:coupons.json`)
+            .shop_id(props.shopID)
+            .promotion_id(props.promotionID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+    }), (q, shopID, promotionID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, promotionID, req });
+        return uid;
+    });
+    couponDelete = batchShopIDAndIDDeletor(this, "couponDelete", plur("coupon(s) deleted"), (ctx) => request(ctx, `DELETE:coupons.json`));
+    domain = batchShopIDAndReqCreator(this, "domain", plur("domain(s) created"), (ctx) => request(ctx, `POST:domains.json`));
+    domainDelete = batchShopIDAndIDDeletor(this, "domainDelete", plur("domain(s) deleted"), (ctx) => request(ctx, `DELETE:domains.json`));
+    reviewDimension = batchShopIDAndReqCreator(this, "reviewDimension", plur("review dimension(s) created"), (ctx) => request(ctx, `POST:review_dimensions.json`));
+    reviewDimensionModify = batchShopIDAndReqAndLocaleModifier(this, "reviewDimensionModify", plur("review dimension(s) modified"), (ctx) => request(ctx, `POST:review_dimensions.json`));
+    reviewDimensionDelete = batchShopIDAndIDDeletor(this, "reviewDimensionDelete", plur("review dimension(s) deleted"), (ctx) => request(ctx, `DELETE:review_dimensions.json`));
+    reviewDimensionSet = batchShopIDAndReqCreator(this, "reviewDimensionSet", plur("review dimension set(s) created"), (ctx) => request(ctx, `POST:review_dimension_sets.json`));
+    reviewDimensionSetModify = batchShopIDAndReqModifier(this, "reviewDimensionSetModify", plur("review dimension set(s) modified"), (ctx) => request(ctx, `POST:review_dimension_sets.json`));
+    reviewDimensionSetDelete = batchShopIDAndIDDeletor(this, "reviewDimensionSetDelete", plur("review dimension set(s) deleted"), (ctx) => request(ctx, `DELETE:review_dimension_sets.json`));
+    customer = batchShopIDAndReqCreator(this, "customer", plur("customer(s) created"), (ctx) => request(ctx, `POST:customers.json`));
+    customerModify = batchShopIDAndReqModifier(this, "customerModify", plur("customer(s) modified"), (ctx) => request(ctx, `POST:customers.json`));
+    customerDelete = batchShopIDAndIDDeletor(this, "customerDelete", plur("customer(s) deleted"), (ctx) => request(ctx, `DELETE:customers.json`));
+    category = batchShopIDAndReqCreator(this, "category", { singular: "category created", plural: "categories created" }, (ctx) => request(ctx, `POST:categories.json`));
+    categoryModify = makeQueue(this, "categoryModify", itemByItemProcessor({ singular: "category modified", plural: "categories modified" }, (ctx, { item }) => {
+        const lctx = { ...ctx, locale: item.locale };
+        return request(lctx, `POST:categories.json`).ids([item.id]).shop_id(item.shopID).data([item.req]).sendUnwrap();
+    }), (q, shopID, id, req, locale) => {
+        const uid = q.unID();
+        q.push(uid, { locale, shopID, id, req });
+    });
+    categoryDelete = batchShopIDAndIDDeletor(this, "categoryDelete", { singular: "category deleted", plural: "categories deleted" }, (ctx) => request(ctx, `DELETE:categories.json`));
+    brand = batchShopIDAndReqCreator(this, "brand", plur("brand(s) created"), (ctx) => request(ctx, `POST:brands.json`));
+    brandModify = makeQueue(this, "brandModify", itemByItemProcessor(plur("brand(s) modified"), (ctx, { item }) => {
+        const lctx = { ...ctx, locale: item.locale };
+        return request(lctx, `POST:brands.json`).ids([item.id]).shop_id(item.shopID).data([item.req]).sendUnwrap();
+    }), (q, shopID, id, req, locale) => {
+        const uid = q.unID();
+        q.push(uid, { locale, shopID, id, req });
+    });
+    brandDelete = batchShopIDAndIDDeletor(this, "brandDelete", plur("brand(s) deleted"), (ctx) => request(ctx, `DELETE:brands.json`));
+    contentBlock = batchShopIDAndReqCreator(this, "contentBlock", plur("content block(s) created"), (ctx) => request(ctx, `POST:content_blocks.json`));
+    contentBlockModify = makeQueue(this, "contentBlockModify", itemByItemProcessor(plur("content block(s) modified"), (ctx, { item }) => {
+        const lctx = { ...ctx, locale: item.locale };
+        return request(lctx, `POST:content_blocks.json`)
+            .ids([item.id])
+            .shop_id(item.shopID)
+            .data([item.req])
+            .sendUnwrap();
+    }), (q, shopID, id, req, locale) => {
+        const uid = q.unID();
+        q.push(uid, { locale, shopID, id, req });
+    });
+    contentBlockDelete = batchShopIDAndIDDeletor(this, "contentBlockDelete", plur("content block(s) deleted"), (ctx) => request(ctx, `DELETE:content_blocks.json`));
+    contentModel = batchShopIDAndReqCreator(this, "contentModel", plur("content model(s) created"), (ctx) => request(ctx, `POST:content_models.json`));
+    contentModelModify = batchShopIDAndReqAndLocaleModifier(this, "contentModelModify", plur("content model(s) modified"), (ctx) => request(ctx, `POST:content_models.json`));
+    contentModelDelete = batchShopIDAndIDDeletor(this, "contentModelDelete", plur("content model(s) deleted"), (ctx) => request(ctx, `DELETE:content_models.json`));
+    menu = makeQueue(this, "menu", itemByItemProcessor(plur("menu(s) created"), (ctx, { item }) => {
+        return request(ctx, `POST:menus.json`).shop_id(item.shopID).data([item.req]).sendUnwrap();
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+        return uid;
+    });
+    menuModify = makeQueue(this, "menuModify", itemByItemProcessor(plur("menu(s) modified"), (ctx, { item }) => {
+        const lctx = { ...ctx, locale: item.locale };
+        return request(lctx, `POST:menus.json`).ids([item.id]).shop_id(item.shopID).data([item.req]).sendUnwrap();
+    }), (q, shopID, id, req, locale) => {
+        const uid = q.unID();
+        q.push(uid, { locale, shopID, id, req });
+    });
+    menuDelete = batchShopIDAndIDDeletor(this, "menuDelete", plur("menu(s) deleted"), (ctx) => request(ctx, `DELETE:menus.json`));
+    option = batchShopIDAndReqCreator(this, "option", plur("option(s) created"), (ctx) => request(ctx, `POST:options.json`));
+    optionModify = batchShopIDAndReqAndLocaleModifier(this, "optionModify", plur("option(s) modified"), (ctx) => request(ctx, `POST:options.json`));
+    optionDelete = batchShopIDAndIDDeletor(this, "optionDelete", plur("option(s) deleted"), (ctx) => request(ctx, `DELETE:options.json`));
+    surveyQuestion = batchShopIDAndReqCreator(this, "surveyQuestion", plur("survey question(s) created"), (ctx) => request(ctx, `POST:survey_questions.json`));
+    surveyQuestionModify = batchShopIDAndReqAndLocaleModifier(this, "surveyQuestionModify", plur("survey question(s) modified"), (ctx) => request(ctx, `POST:survey_questions.json`));
+    surveyQuestionDelete = batchShopIDAndIDDeletor(this, "surveyQuestionDelete", plur("survey question(s) deleted"), (ctx) => request(ctx, `DELETE:survey_questions.json`));
+    uploadFile = makeQueue(this, "uploadFile", itemByItemProcessor(plur("file(s) uploaded"), async (ctx, { item }) => {
+        let result;
+        if (ctx.ws && ctx.token) {
+            result = await uploadFileWebsocket({
+                api: new CommerceFileUploadAPI(ctx),
+                data: item.data,
+                name: item.name,
+                contentType: item.contentType,
+                size: item.data.byteLength,
+                shopID: item.shopID,
+                storage: item.storage,
+                jwt: ctx.token,
+                ws: ctx.ws,
+            });
+        }
+        else {
+            result = await uploadFileGeneric({
+                api: new CommerceFileUploadAPI(ctx),
+                data: item.data,
+                name: item.name,
+                contentType: item.contentType,
+                size: item.data.byteLength,
+                shopID: item.shopID,
+                storage: item.storage,
+            });
+        }
+        if (result.kind !== "ok") {
+            throw new Error(`file upload failure: ${result.kind}`);
+        }
+        return [{ id: result.file.id }];
+    }), (q, shopID, name, data, contentType, storage) => {
+        const uid = q.unID();
+        q.push(uid, {
+            shopID,
+            name,
+            data,
+            contentType,
+            storage,
+            req: null,
+        });
+        return uid;
+    });
+    customerNote = makeQueue(this, "customerNote", batchProcessor(plur("customer note(s) created"), 30, (props) => `${props.shopID}:${props.customerID}`, (ctx, props, items) => {
+        return request(ctx, `POST:customer_notes.json`)
+            .customer_id(props.customerID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, customerID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, customerID, req });
+        return uid;
+    });
+    customerNoteModify = makeQueue(this, "customerNoteModify", batchProcessor(plur("customer note(s) modified"), 30, (props) => `${props.shopID}:${props.customerID}`, (ctx, props, items) => {
+        return request(ctx, `POST:customer_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .customer_id(props.customerID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, customerID, id, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, customerID, req });
+    });
+    customerNoteDelete = makeQueue(this, "customerNoteDelete", batchProcessor(plur("customer note(s) deleted"), 30, (props) => `${props.shopID}:${props.customerID}`, async (ctx, props, items) => {
+        await request(ctx, `DELETE:customer_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .customer_id(props.customerID)
+            .shop_id(props.shopID)
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, customerID, id) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, customerID, req: null });
+    });
+    orderNote = makeQueue(this, "orderNote", batchProcessor(plur("order note(s) created"), 30, (props) => `${props.shopID}:${props.orderID}`, (ctx, props, items) => {
+        return request(ctx, `POST:order_notes.json`)
+            .order_id(props.orderID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, orderID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, orderID, req });
+        return uid;
+    });
+    orderNoteModify = makeQueue(this, "orderNoteModify", batchProcessor(plur("order note(s) modified"), 30, (props) => `${props.shopID}:${props.orderID}`, (ctx, props, items) => {
+        return request(ctx, `POST:order_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .order_id(props.orderID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, orderID, id, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, orderID, req });
+    });
+    orderNoteDelete = makeQueue(this, "orderNoteDelete", batchProcessor(plur("order note(s) deleted"), 30, (props) => `${props.shopID}:${props.orderID}`, async (ctx, props, items) => {
+        await request(ctx, `DELETE:order_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .order_id(props.orderID)
+            .shop_id(props.shopID)
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, orderID, id) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, orderID, req: null });
+    });
+    purchaseOrderNote = makeQueue(this, "purchaseOrderNote", batchProcessor(plur("purchase order note(s) created"), 30, (props) => `${props.shopID}:${props.purchaseOrderID}`, (ctx, props, items) => {
+        return request(ctx, `POST:purchase_order_notes.json`)
+            .purchase_order_id(props.purchaseOrderID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, purchaseOrderID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, purchaseOrderID, req });
+        return uid;
+    });
+    purchaseOrderNoteModify = makeQueue(this, "purchaseOrderNoteModify", batchProcessor(plur("purchase order note(s) modified"), 30, (props) => `${props.shopID}:${props.purchaseOrderID}`, (ctx, props, items) => {
+        return request(ctx, `POST:purchase_order_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .purchase_order_id(props.purchaseOrderID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, purchaseOrderID, id, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, purchaseOrderID, req });
+    });
+    purchaseOrderNoteDelete = makeQueue(this, "purchaseOrderNoteDelete", batchProcessor(plur("purchase order note(s) deleted"), 30, (props) => `${props.shopID}:${props.purchaseOrderID}`, async (ctx, props, items) => {
+        await request(ctx, `DELETE:purchase_order_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .purchase_order_id(props.purchaseOrderID)
+            .shop_id(props.shopID)
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, purchaseOrderID, id) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, purchaseOrderID, req: null });
+    });
+    transferNote = makeQueue(this, "transferNote", batchProcessor(plur("transfer note(s) created"), 30, (props) => `${props.shopID}:${props.transferID}`, (ctx, props, items) => {
+        return request(ctx, `POST:purchase_order_notes.json`)
+            .purchase_order_id(props.transferID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, transferID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, transferID, req });
+        return uid;
+    });
+    transferNoteModify = makeQueue(this, "transferNoteModify", batchProcessor(plur("transfer note(s) modified"), 30, (props) => `${props.shopID}:${props.transferID}`, (ctx, props, items) => {
+        return request(ctx, `POST:transfer_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .transfer_id(props.transferID)
+            .data(items.map((v) => v.item.req))
+            .shop_id(props.shopID)
+            .sendUnwrap();
+    }), (q, shopID, transferID, id, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, transferID, req });
+    });
+    transferNoteDelete = makeQueue(this, "transferNoteDelete", batchProcessor(plur("transfer note(s) deleted"), 30, (props) => `${props.shopID}:${props.transferID}`, async (ctx, props, items) => {
+        await request(ctx, `DELETE:transfer_notes.json`)
+            .ids(items.map((v) => v.item.id))
+            .transfer_id(props.transferID)
+            .shop_id(props.shopID)
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, transferID, id) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, transferID, req: null });
+    });
+    order = batchShopIDAndReqCreator(this, "order", plur("order(s) created"), (ctx) => request(ctx, `POST:orders.json`));
+    orderModify = batchShopIDAndReqModifier(this, "orderModify", plur("order(s) modified"), (ctx) => request(ctx, `POST:orders.json`));
+    orderDelete = batchShopIDAndIDDeletor(this, "orderDelete", plur("order(s) deleted"), (ctx) => request(ctx, `DELETE:orders.json`));
+    purchaseOrder = batchShopIDAndReqCreator(this, "purchaseOrder", plur("purchase order(s) created"), (ctx) => request(ctx, `POST:purchase_orders.json`));
+    purchaseOrderModify = batchShopIDAndReqModifier(this, "purchaseOrderModify", plur("purchase order(s) modified"), (ctx) => request(ctx, `POST:purchase_orders.json`));
+    purchaseOrderDelete = batchShopIDAndIDDeletor(this, "purchaseOrderDelete", plur("purchase order(s) deleted"), (ctx) => request(ctx, `DELETE:purchase_orders.json`));
+    transfer = batchShopIDAndReqCreator(this, "transfer", plur("transfer(s) created"), (ctx) => request(ctx, `POST:transfers.json`));
+    transferModify = batchShopIDAndReqModifier(this, "transferModify", plur("transfer(s) modified"), (ctx) => request(ctx, `POST:transfers.json`));
+    transferDelete = batchShopIDAndIDDeletor(this, "transferDelete", plur("transfer(s) deleted"), (ctx) => request(ctx, `DELETE:transfers.json`));
+    supplier = batchShopIDAndReqCreator(this, "supplier", plur("supplier(s) created"), (ctx) => request(ctx, `POST:suppliers.json`));
+    supplierModify = batchShopIDAndReqModifier(this, "supplierModify", plur("supplier(s) modified"), (ctx) => request(ctx, `POST:suppliers.json`));
+    supplierDelete = batchShopIDAndIDDeletor(this, "supplierDelete", plur("supplier(s) deleted"), (ctx) => request(ctx, `DELETE:suppliers.json`));
+    packaging = batchShopIDAndReqCreator(this, "packaging", plur("packaging configuration(s) created"), (ctx) => request(ctx, `POST:packaging.json`));
+    packagingModify = batchShopIDAndReqModifier(this, "packagingModify", plur("packaging configuration(s) modified"), (ctx) => request(ctx, `POST:packaging.json`));
+    packagingDelete = batchShopIDAndIDDeletor(this, "packagingDelete", plur("packaging configuration(s) deleted"), (ctx) => request(ctx, `DELETE:packaging.json`));
+    invitation = batchShopIDAndReqCreator(this, "invitation", plur("invitation(s) created"), (ctx) => request(ctx, `POST:invitations.json`));
+    invitationDelete = batchShopIDAndIDDeletor(this, "invitationDelete", plur("invitation(s) deleted"), (ctx) => request(ctx, `DELETE:invitations.json`));
+    buyLink = batchShopIDAndReqCreator(this, "buyLink", plur("buy link(s) created"), (ctx) => request(ctx, `POST:buy_links.json`));
+    buyLinkModify = batchShopIDAndReqModifier(this, "buyLinkModify", plur("buy link(s) modified"), (ctx) => request(ctx, `POST:buy_links.json`));
+    buyLinkDelete = batchShopIDAndIDDeletor(this, "buyLinkDelete", plur("buy link(s) deleted"), (ctx) => request(ctx, `DELETE:buy_links.json`));
+    customerGroup = batchShopIDAndReqCreator(this, "customerGroup", plur("customer group(s) created"), (ctx) => request(ctx, `POST:customer_groups.json`));
+    customerGroupModify = batchShopIDAndReqModifier(this, "customerGroupModify", plur("customer group(s) modified"), (ctx) => request(ctx, `POST:customer_groups.json`));
+    customerGroupDelete = batchShopIDAndIDDeletor(this, "customerGroupDelete", plur("customer group(s) deleted"), (ctx) => request(ctx, `DELETE:customer_groups.json`));
+    dataFeed = batchShopIDAndReqCreator(this, "dataFeed", plur("data feed(s) created"), (ctx) => request(ctx, `POST:data_feeds.json`));
+    dataFeedModify = batchShopIDAndReqModifier(this, "dataFeedModify", plur("data feed(s) modified"), (ctx) => request(ctx, `POST:data_feeds.json`));
+    dataFeedDelete = batchShopIDAndIDDeletor(this, "dataFeedDelete", plur("data feed(s) deleted"), (ctx) => request(ctx, `DELETE:data_feeds.json`));
+    inventoryRule = batchShopIDAndReqCreator(this, "inventoryRule", plur("inventory rule(s) created"), (ctx) => request(ctx, `POST:inventory_rules.json`));
+    inventoryRuleModify = batchShopIDAndReqModifier(this, "inventoryRuleModify", plur("inventory rule(s) modified"), (ctx) => request(ctx, `POST:inventory_rules.json`));
+    inventoryRuleDelete = batchShopIDAndIDDeletor(this, "inventoryRuleDelete", plur("inventory rule(s) deleted"), (ctx) => request(ctx, `DELETE:inventory_rules.json`));
+    returnInspection = batchShopIDAndReqCreator(this, "returnInspection", plur("return inspection(s) created"), (ctx) => request(ctx, `POST:return_inspections.json`));
+    returnInspectionModify = batchShopIDAndReqModifier(this, "returnInspectionModify", plur("return inspection(s) modified"), (ctx) => request(ctx, `POST:return_inspections.json`));
+    returnInspectionDelete = batchShopIDAndIDDeletor(this, "returnInspectionDelete", plur("return inspection(s) deleted"), (ctx) => request(ctx, `DELETE:return_inspections.json`));
+    scheduledFulfillment = makeQueue(this, "scheduledFulfillment", batchProcessor(plur("scheduled fulfillment(s) created"), 30, (props) => `${props.shopID}:${props.orderID}`, (ctx, props, items) => {
+        return request(ctx, `POST:scheduled_fulfillments.json`)
+            .shop_id(props.shopID)
+            .order_id(props.orderID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+    }), (q, shopID, orderID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, orderID, req });
+        return uid;
+    });
+    scheduledFulfillmentModify = makeQueue(this, "scheduledFulfillmentModify", batchProcessor(plur("scheduled fulfillment(s) modified"), 30, (props) => `${props.shopID}:${props.orderID}`, (ctx, props, items) => {
+        return request(ctx, `POST:scheduled_fulfillments.json`)
+            .ids(items.map((v) => v.item.id))
+            .shop_id(props.shopID)
+            .order_id(props.orderID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+    }), (q, shopID, orderID, id, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, orderID, id, req });
+    });
+    scheduledFulfillmentDelete = makeQueue(this, "scheduledFulfillmentDelete", batchProcessor(plur("scheduled fulfillment(s) deleted"), 30, (props) => `${props.shopID}:${props.orderID}`, async (ctx, props, items) => {
+        await request(ctx, `DELETE:scheduled_fulfillments.json`)
+            .ids(items.map((v) => v.id))
+            .order_id(props.orderID)
+            .shop_id(props.shopID)
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, orderID, id) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, id, orderID, req: null });
+    });
+    role = batchShopIDAndReqCreator(this, "role", plur("role(s) created"), (ctx) => request(ctx, `POST:roles.json`));
+    roleModify = batchShopIDAndReqModifier(this, "roleModify", plur("role(s) modified"), (ctx) => request(ctx, `POST:roles.json`));
+    roleDelete = batchShopIDAndIDDeletor(this, "roleDelete", plur("role(s) deleted"), (ctx) => request(ctx, `DELETE:roles.json`));
+    returnPolicy = batchShopIDAndReqCreator(this, "returnPolicy", { plural: "return policies created", singular: "return policy created" }, (ctx) => request(ctx, `POST:return_policies.json`));
+    returnPolicyModify = batchShopIDAndReqModifier(this, "returnPolicyModify", { plural: "return policies modified", singular: "return policy modified" }, (ctx) => request(ctx, `POST:return_policies.json`));
+    returnPolicyDelete = batchShopIDAndIDDeletor(this, "returnPolicyDelete", { plural: "return policies deleted", singular: "return policy deleted" }, (ctx) => request(ctx, `DELETE:return_policies.json`));
+    optionSet = batchShopIDAndReqCreator(this, "optionSet", plur("option set(s) created"), (ctx) => request(ctx, `POST:option_sets.json`));
+    optionSetModify = batchShopIDAndReqModifier(this, "optionSetModify", plur("option set(s) modified"), (ctx) => request(ctx, `POST:option_sets.json`));
+    optionSetDelete = batchShopIDAndIDDeletor(this, "optionSetDelete", plur("option set(s) deleted"), (ctx) => request(ctx, `DELETE:option_sets.json`));
+    productFieldSet = batchShopIDAndReqCreator(this, "productFieldSet", plur("product field set(s) created"), (ctx) => request(ctx, `POST:product_field_sets.json`));
+    productFieldSetModify = batchShopIDAndReqAndLocaleModifier(this, "productFieldSetModify", plur("product field set(s) modified"), (ctx) => request(ctx, `POST:product_field_sets.json`));
+    productFieldSetDelete = batchShopIDAndIDDeletor(this, "productFieldSetDelete", plur("product field set(s) deleted"), (ctx) => request(ctx, `DELETE:product_field_sets.json`));
+    key = batchShopIDAndReqCreator(this, "key", plur("key(s) created"), (ctx) => request(ctx, `POST:keys.json`));
+    keyModify = batchShopIDAndReqModifier(this, "keyModify", plur("key(s) modified"), (ctx) => request(ctx, `POST:keys.json`));
+    keyDelete = batchShopIDAndIDDeletor(this, "keyDelete", plur("key(s) deleted"), (ctx) => request(ctx, `DELETE:keys.json`));
+    product = batchShopIDAndReqCreator(this, "product", plur("product(s) created"), (ctx) => request(ctx, `POST:products.json`));
+    productModify = batchShopIDAndReqAndLocaleModifier(this, "productModify", plur("product(s) modified"), (ctx) => request(ctx, `POST:products.json`));
+    productDelete = batchShopIDAndIDDeletor(this, "productDelete", plur("product(s) deleted"), (ctx) => request(ctx, `DELETE:products.json`));
+    variant = makeQueue(this, "variant", batchProcessor(plur("product variant(s) created"), 30, (props) => props.shopID, (ctx, props, items) => {
+        return request(ctx, `POST:product_variants.json`)
+            .shop_id(props.shopID)
+            .data(items.map((v) => ({ ...v.item.req, product_id: v.item.productID })))
+            .sendUnwrap();
+    }), (q, shopID, productID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, productID, req });
+        return uid;
+    });
+    variantModify = batchShopIDAndReqAndLocaleModifier(this, "variantModify", plur("product variant(s) modified"), (ctx) => request(ctx, `POST:product_variants.json`));
+    variantDelete = batchShopIDAndIDDeletor(this, "variantDelete", plur("product variant(s) deleted"), (ctx) => request(ctx, `DELETE:product_variants.json`));
+    currency = makeQueue(this, "currency", batchProcessor({ singular: "currency created", plural: "currencies created" }, 30, (props) => props.shopID, async (ctx, props, items) => {
+        await request(ctx, `POST:currencies.json`)
+            .shop_id(props.shopID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+        return uid;
+    });
+    review = makeQueue(this, "review", batchProcessor(plur("review(s) created"), 30, (props) => `${props.shopID}:${props.req.product_id}`, (ctx, props, items) => {
+        return request(ctx, `POST:product_reviews.json`)
+            .shop_id(props.shopID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+        return uid;
+    });
+    question = makeQueue(this, "question", batchProcessor(plur("question(s) created"), 30, (props) => `${props.shopID}:${props.req.product_id}`, (ctx, props, items) => {
+        return request(ctx, `POST:product_questions.json`)
+            .shop_id(props.shopID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+    }), (q, shopID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, req });
+        return uid;
+    });
+    variantInventory = makeQueue(this, "variantInventory", batchProcessor({ singular: "inventory entry set", plural: "inventory entries set" }, 30, (props) => `${props.shopID}:${props.variantID}`, async (ctx, props, items) => {
+        await request(ctx, `POST:variant_inventory.json`)
+            .shop_id(props.shopID)
+            .variant_id(props.variantID)
+            .data(items.map((v) => v.item.req))
+            .sendUnwrap();
+        return null;
+    }), (q, shopID, variantID, req) => {
+        const uid = q.unID();
+        q.push(uid, { shopID, variantID, req });
+        return uid;
+    });
+    countTotalNumberOfItems() {
+        let totalItems = 0;
+        for (const b of this.batches) {
+            totalItems += b.numberOfItems();
+            if (b.barrier) {
+                totalItems++;
+            }
+        }
+        return totalItems;
+    }
+    async execute(ctx, logger = new NullLogger()) {
+        const t0 = +new Date();
+        const resolvedIDs = new Map();
+        const ectx = {
+            batchNum: 0,
+            numTotal: this.countTotalNumberOfItems(),
+            numComplete: 0,
+        };
+        logger.line(`╒═══════════════════════════════════════════════════════════════════╕`);
+        logger.line(`│ Executing (${ectx.numTotal} items)`.padEnd(68, " ") + "│");
+        logger.line(`├───────────────────────────────────────────────────────────────────┘`);
+        for (const b of this.batches) {
+            for (const batch of b.topoSort(resolvedIDs.keys())) {
+                const batchStr = `Batch #${++ectx.batchNum}`;
+                const bar = logger.bar("└─ {job} [{bar}] | {percentage}% | ETA: {eta}s | {value}/{total}");
+                const statsExecuteContext = new StatsExecuteContext(batchStr, this.opts, (v) => {
+                    bar.increment(v);
+                    ectx.numComplete += v;
+                });
+                bar.start(ectx.numTotal, ectx.numComplete, { job: batchStr });
+                let result = [];
+                if (this.opts.sequential) {
+                    for (const b of batch) {
+                        result.push(await b.processor(statsExecuteContext, ctx, b.items, resolvedIDs));
+                    }
+                }
+                else {
+                    result = await Promise.all(batch.map((b) => b.processor(statsExecuteContext, ctx, b.items, resolvedIDs)));
+                }
+                statsExecuteContext.done();
+                bar.stop();
+                const newIDs = result.reduce((a, b) => a.concat(b), []);
+                for (const [key, val] of newIDs) {
+                    resolvedIDs.set(key, val);
+                }
+                // report stats
+                const bstats = {};
+                const tree = {
+                    [`${batchStr} [${statsExecuteContext.stats.secondsElapsed.toFixed(3)}s]`]: bstats,
+                };
+                for (const [name, stat] of Array.from(statsExecuteContext.stats.stats.entries())) {
+                    const apiCalls = stat.apiCalls === 1 ? `1 api call` : `${stat.apiCalls} api calls`;
+                    const nm = formatName(name, stat.objects);
+                    bstats[`${stat.objects} ${nm} (${apiCalls}) [${stat.secondsElapsed.toFixed(3)}s]`] = "";
+                }
+                logger.tree(tree);
+            }
+            if (b.barrier) {
+                const barrierStr = `Barrier #${ectx.batchNum}: ${b.barrier.desc}`;
+                const bar = logger.bar("└─ {job} [{bar}] | {percentage}% | ETA: {eta}s | {value}/{total}");
+                bar.start(ectx.numTotal, ectx.numComplete, { job: barrierStr });
+                const statsExecuteContext = new StatsExecuteContext(barrierStr, this.opts);
+                applyResolvedIDs(b.barrier.data, resolvedIDs);
+                await b.barrier.func(b.barrier.data);
+                bar.increment();
+                ectx.numComplete++;
+                statsExecuteContext.done();
+                bar.stop();
+                const tree = {
+                    [`${barrierStr} [${statsExecuteContext.stats.secondsElapsed.toFixed(3)}s]`]: {},
+                };
+                logger.tree(tree);
+            }
+        }
+        const t1 = +new Date();
+        const elapsed = (t1 - t0) / 1000;
+        logger.line(`├───────────────────────────────────────────────────────────────────┐`);
+        logger.line(`│ Total seconds elapsed: ${elapsed.toFixed(3)}s`.padEnd(68, " ") + "│");
+        logger.line(`╘═══════════════════════════════════════════════════════════════════╛`);
+        return {
+            resolvedIDs,
+        };
+    }
+}