@porulle/adapter-woocommerce 0.74.1 → 0.74.3

package/dist/catalog.js

@@ -59,8 +59,49 @@ function status(value) {
         return "draft";
     return undefined;
 }
-function variant(row, currency) {
-    const optionValues = Object.fromEntries(row.attributes.flatMap((attribute) => (attribute.option ? [[attribute.name, attribute.option]] : [])));
+/** "pa_color", "Color" and "color" are one attribute; "Blue" and the term slug "blue" one value. */
+function attributeKey(value) {
+    return value.trim().toLowerCase().replace(/^pa_/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+/**
+ * The option axes a variable product sells along. WooCommerce lets a variation use a global
+ * attribute (`pa_color`) by its term SLUG ("blue") while the product lists the term NAME ("Blue") —
+ * or does not list that attribute at all (measured on WooCommerce's own sample catalogue). The axes
+ * are the product's declared variation attributes plus any its variations use, and each value is
+ * spelled as the product spells it where it declares one, so every variant's values are among them.
+ */
+function optionAxes(product, variations) {
+    const axes = new Map();
+    for (const attribute of product.attributes.filter((candidate) => candidate.variation === true)) {
+        axes.set(attributeKey(attribute.name), { name: attribute.name, values: [...attribute.options] });
+    }
+    const resolve = (name, option) => {
+        const key = attributeKey(name);
+        let axis = axes.get(key);
+        if (!axis) {
+            axis = { name: name.replace(/^pa_/, "").replace(/^./, (first) => first.toUpperCase()), values: [] };
+            axes.set(key, axis);
+        }
+        const declared = axis.values.find((value) => attributeKey(value) === attributeKey(option));
+        if (declared)
+            return { name: axis.name, value: declared };
+        const shown = option.replace(/^./, (first) => first.toUpperCase());
+        axis.values.push(shown);
+        return { name: axis.name, value: shown };
+    };
+    for (const row of variations)
+        for (const attribute of row.attributes)
+            if (attribute.option)
+                resolve(attribute.name, attribute.option);
+    return { axes: [...axes.values()], resolve };
+}
+function variant(row, currency, resolve) {
+    const optionValues = Object.fromEntries(row.attributes.flatMap((attribute) => {
+        if (!attribute.option)
+            return [];
+        const resolved = resolve(attribute.name, attribute.option);
+        return [[resolved.name, resolved.value]];
+    }));
     const rowPrices = prices(row, currency);
     return {
         externalId: row.id,
@@ -94,15 +135,17 @@ export function catalogItem(product, variations, currency) {
             images.push({ externalId: row.image.id, url: row.image.src, ...(row.image.alt ? { alt: row.image.alt } : {}), role: "gallery", sortOrder: images.length, variantExternalIds: [row.id] });
         }
     }
-    const options = product.attributes.filter((attribute) => attribute.variation === true).map((attribute, index) => ({
-        name: attribute.name,
-        displayName: attribute.name,
-        sortOrder: attribute.position ?? index,
-        values: attribute.options.map((value, valueIndex) => ({ value, displayValue: value, sortOrder: valueIndex })),
-    }));
+    const sellable = product.type === "simple" ? [] : variations.filter((row) => row.status !== "private");
+    const { axes, resolve } = optionAxes(product, sellable);
     const variants = product.type === "simple"
-        ? [variant({ id: product.id, sku: product.sku, price: product.price, regular_price: product.regular_price, sale_price: product.sale_price, attributes: [] }, currency)]
-        : variations.filter((row) => row.status !== "private").map((row) => variant(row, currency));
+        ? [variant({ id: product.id, sku: product.sku, price: product.price, regular_price: product.regular_price, sale_price: product.sale_price, attributes: [] }, currency, resolve)]
+        : sellable.map((row) => variant(row, currency, resolve));
+    const options = product.type === "simple" ? [] : axes.map((axis, index) => ({
+        name: axis.name,
+        displayName: axis.name,
+        sortOrder: index,
+        values: axis.values.map((value, valueIndex) => ({ value, displayValue: value, sortOrder: valueIndex })),
+    }));
     const itemStatus = status(product.status);
     return {
         externalId: product.id,

package/dist/index.js

@@ -38,7 +38,7 @@ export function wooConnector(options = {}) {
         async probeStore(input) {
             const storeDomain = normalizeStoreDomain(input, { allowPrivateHosts: transport.allowPrivateHosts });
             if (!storeDomain) {
-                const why = transport.allowPrivateHosts ? undefined : refusedStoreUrl(input);
+                const why = refusedStoreUrl(input);
                 return refused(why === "http" ? "WOO_STORE_NOT_HTTPS" : "WOO_INVALID_STORE_DOMAIN", why === "http"
                     ? "Your store must be served over https (with a valid certificate) to connect."
                     : why === "private_host" ? "That address is not a public website." : `"${input}" is not a store address. Enter it like https://shop.example.com.`);

package/dist/orders.js

@@ -142,9 +142,10 @@ export async function pushOrder(client, slice, options) {
         // A refusal can leave a checkout-draft behind; it is ours, so it goes.
         if (draftId?.success)
             await client.send("DELETE", `/wc/v3/orders/${draftId.data}`, undefined, z.unknown(), { force: "true" });
-        // A 4xx is the store's answer. Anything else (timeout, 5xx, unreadable) may have created the
-        // order: retriable, and the next attempt looks for it before creating.
-        const answered = error.status !== undefined && error.status >= 400 && error.status < 500;
+        // A 4xx WooCommerce explained (its JSON error) is the store's answer. Anything else — a timeout,
+        // a 5xx, a firewall's page — may or may not have created the order: retriable, and the next
+        // attempt looks for it before creating anything.
+        const answered = error.status !== undefined && error.status >= 400 && error.status < 500 && error.body !== undefined;
         return Err({ code: answered ? "WOO_ORDER_REJECTED" : error.code, message: answered ? `WooCommerce refused the order: ${error.message}` : `The store's answer to the order was lost (${error.message}); it is looked for before trying again.`, retriable: !answered });
     }
     const order = created.value;