medusa-plugin-ordinant 0.1.0

package/.medusa/server/src/api/admin/ordinant/classifications/[sku]/confirm/route.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const utils_1 = require("@medusajs/framework/utils");
+const confirm_classification_1 = require("../../../../../../workflows/confirm-classification");
+/**
+ * POST /admin/ordinant/classifications/{sku}/confirm
+ *
+ * Records the merchant's attestation for a SKU with the final attribute set
+ * (the proposal as-is, or edited in the widget). Ordinant validates the
+ * attributes against its dictionary; violations surface as 4xx errors the
+ * widget displays inline.
+ */
+async function POST(req, res) {
+    const sku = req.params.sku;
+    const attributes = req.body?.attributes;
+    if (!attributes || Object.keys(attributes).length === 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "attributes is required — confirmation attests to a specific attribute set");
+    }
+    const { result } = await (0, confirm_classification_1.confirmClassificationWorkflow)(req.scope).run({
+        input: { sku, attributes },
+    });
+    res.json(result);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L2NsYXNzaWZpY2F0aW9ucy9bc2t1XS9jb25maXJtL3JvdXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBZ0JBLG9CQWlCQztBQWhDRCxxREFBdUQ7QUFDdkQsK0ZBQWtHO0FBTWxHOzs7Ozs7O0dBT0c7QUFDSSxLQUFLLFVBQVUsSUFBSSxDQUN4QixHQUE0QyxFQUM1QyxHQUFtQjtJQUVuQixNQUFNLEdBQUcsR0FBRyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQTtJQUMxQixNQUFNLFVBQVUsR0FBRyxHQUFHLENBQUMsSUFBSSxFQUFFLFVBQVUsQ0FBQTtJQUN2QyxJQUFJLENBQUMsVUFBVSxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3hELE1BQU0sSUFBSSxtQkFBVyxDQUNuQixtQkFBVyxDQUFDLEtBQUssQ0FBQyxZQUFZLEVBQzlCLDJFQUEyRSxDQUM1RSxDQUFBO0lBQ0gsQ0FBQztJQUVELE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxNQUFNLElBQUEsc0RBQTZCLEVBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsQ0FBQztRQUNwRSxLQUFLLEVBQUUsRUFBRSxHQUFHLEVBQUUsVUFBVSxFQUFFO0tBQzNCLENBQUMsQ0FBQTtJQUNGLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7QUFDbEIsQ0FBQyJ9

package/.medusa/server/src/api/admin/ordinant/classifications/bulk-confirm/route.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const utils_1 = require("@medusajs/framework/utils");
+const bulk_operations_1 = require("../../../../../workflows/bulk-operations");
+/** Cap per request; the admin page chunks larger selections. */
+const maxSkus = 100;
+/**
+ * POST /admin/ordinant/classifications/bulk-confirm
+ *
+ * Confirms the listed SKUs' proposals AS PROPOSED — a bulk attestation.
+ * The admin page shows a category-grouped summary of exactly what is being
+ * attested before calling this; the merchant remains the classifier of
+ * record.
+ */
+async function POST(req, res) {
+    const skus = req.body?.skus;
+    if (!Array.isArray(skus) || skus.length === 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "skus is required");
+    }
+    if (skus.length > maxSkus) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `at most ${maxSkus} skus per request — chunk larger selections`);
+    }
+    const { result } = await (0, bulk_operations_1.bulkConfirmWorkflow)(req.scope).run({
+        input: { skus },
+    });
+    res.json({ results: result });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L2NsYXNzaWZpY2F0aW9ucy9idWxrLWNvbmZpcm0vcm91dGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFtQkEsb0JBa0JDO0FBcENELHFEQUF1RDtBQUN2RCw4RUFBOEU7QUFNOUUsZ0VBQWdFO0FBQ2hFLE1BQU0sT0FBTyxHQUFHLEdBQUcsQ0FBQTtBQUVuQjs7Ozs7OztHQU9HO0FBQ0ksS0FBSyxVQUFVLElBQUksQ0FDeEIsR0FBZ0QsRUFDaEQsR0FBbUI7SUFFbkIsTUFBTSxJQUFJLEdBQUcsR0FBRyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUE7SUFDM0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUM5QyxNQUFNLElBQUksbUJBQVcsQ0FBQyxtQkFBVyxDQUFDLEtBQUssQ0FBQyxZQUFZLEVBQUUsa0JBQWtCLENBQUMsQ0FBQTtJQUMzRSxDQUFDO0lBQ0QsSUFBSSxJQUFJLENBQUMsTUFBTSxHQUFHLE9BQU8sRUFBRSxDQUFDO1FBQzFCLE1BQU0sSUFBSSxtQkFBVyxDQUNuQixtQkFBVyxDQUFDLEtBQUssQ0FBQyxZQUFZLEVBQzlCLFdBQVcsT0FBTyw2Q0FBNkMsQ0FDaEUsQ0FBQTtJQUNILENBQUM7SUFDRCxNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsTUFBTSxJQUFBLHFDQUFtQixFQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLENBQUM7UUFDMUQsS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFO0tBQ2hCLENBQUMsQ0FBQTtJQUNGLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQTtBQUMvQixDQUFDIn0=

package/.medusa/server/src/api/admin/ordinant/classifications/route.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const ordinant_1 = require("../../../../modules/ordinant");
+/**
+ * GET /admin/ordinant/classifications?skus=a,b,c
+ *
+ * Proxies the merchant's Ordinant classifications for the admin widget,
+ * optionally filtered to a product's SKUs. The Ordinant API key stays
+ * server-side; the dashboard authenticates as an ordinary admin user.
+ */
+async function GET(req, res) {
+    const ordinant = req.scope.resolve(ordinant_1.ORDINANT_MODULE);
+    const skusParam = typeof req.query.skus === "string" ? req.query.skus : "";
+    const skus = new Set(skusParam
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean));
+    const { items } = await ordinant.client.listClassifications(undefined, 500);
+    const filtered = skus.size > 0 ? items.filter((c) => skus.has(c.sku)) : items;
+    res.json({ items: filtered });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L2NsYXNzaWZpY2F0aW9ucy9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVdBLGtCQWFDO0FBdkJELDJEQUE4RDtBQUc5RDs7Ozs7O0dBTUc7QUFDSSxLQUFLLFVBQVUsR0FBRyxDQUFDLEdBQStCLEVBQUUsR0FBbUI7SUFDNUUsTUFBTSxRQUFRLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQXdCLDBCQUFlLENBQUMsQ0FBQTtJQUMxRSxNQUFNLFNBQVMsR0FBRyxPQUFPLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQTtJQUMxRSxNQUFNLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FDbEIsU0FBUztTQUNOLEtBQUssQ0FBQyxHQUFHLENBQUM7U0FDVixHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztTQUNwQixNQUFNLENBQUMsT0FBTyxDQUFDLENBQ25CLENBQUE7SUFFRCxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxRQUFRLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFDLFNBQVMsRUFBRSxHQUFHLENBQUMsQ0FBQTtJQUMzRSxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFBO0lBQzdFLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQTtBQUMvQixDQUFDIn0=

package/.medusa/server/src/api/admin/ordinant/classify-all/route.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const utils_1 = require("@medusajs/framework/utils");
+const ordinant_1 = require("../../../../modules/ordinant");
+const bulk_operations_1 = require("../../../../workflows/bulk-operations");
+const client_1 = require("../../../../lib/client");
+/** SKUs per invocation — kept modest so each request finishes in a few
+ * seconds even at real model latency, giving smooth progress and headroom
+ * under every timeout; the admin page loops until `remaining` reaches zero. */
+const chunkSize = 20;
+/**
+ * POST /admin/ordinant/classify-all
+ *
+ * Classifies the next chunk of UNCLASSIFIED SKUs (products that predate the
+ * plugin, or whose classification previously failed). Returns how many
+ * remain so the caller can keep going.
+ */
+async function POST(req, res) {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const ordinant = req.scope.resolve(ordinant_1.ORDINANT_MODULE);
+    const [{ data: products }, { items: classifications }] = await Promise.all([
+        query.graph({
+            entity: "product",
+            fields: [
+                "id",
+                "title",
+                "description",
+                "type.value",
+                "collection.title",
+                "variants.sku",
+                "variants.title",
+            ],
+            pagination: { take: 1000, skip: 0 },
+        }),
+        ordinant.client.listClassifications(undefined, 5000),
+    ]);
+    const classified = new Set(classifications.map((c) => c.sku));
+    const backlog = [];
+    for (const product of products) {
+        for (const variant of product.variants ?? []) {
+            if (!variant?.sku || classified.has(variant.sku)) {
+                continue;
+            }
+            backlog.push({
+                sku: variant.sku,
+                title: variant.title && variant.title !== "Default variant"
+                    ? `${product.title} — ${variant.title}`
+                    : product.title,
+                description: product.description ?? undefined,
+                product_type: product.type?.value ?? product.collection?.title ?? undefined,
+            });
+        }
+    }
+    const chunk = backlog.slice(0, chunkSize);
+    let proposed = 0;
+    let failed = 0;
+    if (chunk.length > 0) {
+        let result;
+        try {
+            ;
+            ({ result } = await (0, bulk_operations_1.bulkClassifyWorkflow)(req.scope).run({
+                input: { items: chunk },
+            }));
+        }
+        catch (error) {
+            // A whole-request failure (engine down, or classification disabled
+            // server-side) is a configuration problem the merchant can act on —
+            // surface it clearly instead of a generic 500. The workflow may wrap
+            // the OrdinantApiError, so match on the 503 signal in the message.
+            const cause = unwrap(error);
+            const message = cause instanceof Error ? cause.message : String(cause);
+            const disabled = (cause instanceof client_1.OrdinantApiError && cause.status === 503) ||
+                /not enabled|service_unavailable|503/i.test(message);
+            if (disabled) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Ordinant classification is not enabled. Set ORDINANT_CLASSIFY_ENABLED " +
+                    "and ANTHROPIC_API_KEY on the Ordinant deployment.");
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Classification request failed: ${message}`);
+        }
+        for (const r of result) {
+            if (r.error) {
+                failed++;
+            }
+            else {
+                proposed++;
+            }
+        }
+    }
+    res.json({
+        processed: chunk.length,
+        proposed,
+        failed,
+        remaining: backlog.length - chunk.length,
+    });
+}
+/** unwrap peels one layer of error wrapping (Medusa workflows re-throw step
+ * errors) without relying on the ES2022 `Error.cause` typing. */
+function unwrap(error) {
+    if (error && typeof error === "object" && "cause" in error) {
+        const cause = error.cause;
+        if (cause) {
+            return cause;
+        }
+    }
+    return error;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/admin/ordinant/dictionary/route.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const ordinant_1 = require("../../../../modules/ordinant");
+/**
+ * GET /admin/ordinant/dictionary
+ *
+ * The attribute dictionary the current ruleset decides against. The admin UI
+ * renders its classification dropdowns from this — the dictionary IS the
+ * form schema, so new legal attributes appear automatically with no UI code.
+ */
+async function GET(req, res) {
+    const ordinant = req.scope.resolve(ordinant_1.ORDINANT_MODULE);
+    const dictionary = await ordinant.client.getDictionary();
+    res.json(dictionary);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L2RpY3Rpb25hcnkvcm91dGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFXQSxrQkFJQztBQWRELDJEQUE4RDtBQUc5RDs7Ozs7O0dBTUc7QUFDSSxLQUFLLFVBQVUsR0FBRyxDQUFDLEdBQStCLEVBQUUsR0FBbUI7SUFDNUUsTUFBTSxRQUFRLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQXdCLDBCQUFlLENBQUMsQ0FBQTtJQUMxRSxNQUFNLFVBQVUsR0FBRyxNQUFNLFFBQVEsQ0FBQyxNQUFNLENBQUMsYUFBYSxFQUFFLENBQUE7SUFDeEQsR0FBRyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQTtBQUN0QixDQUFDIn0=

package/.medusa/server/src/api/admin/ordinant/generate-all-skus/route.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const utils_1 = require("@medusajs/framework/utils");
+const generate_skus_1 = require("../../../../workflows/generate-skus");
+/**
+ * POST /admin/ordinant/generate-all-skus
+ *
+ * Generates SKUs for every product that has a SKU-less variant, in one
+ * action. SKU generation is DB-only (fast), so this runs synchronously;
+ * classification of the newly-SKU'd products is left to the caller's
+ * classify-all pass (the dashboard chains them behind one button).
+ */
+async function POST(req, res) {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: products } = await query.graph({
+        entity: "product",
+        fields: ["id", "variants.sku"],
+        pagination: { take: 1000, skip: 0 },
+    });
+    const needsSku = products.filter((p) => (p.variants ?? []).some((v) => !v?.sku));
+    let generated = 0;
+    for (const product of needsSku) {
+        const { result } = await (0, generate_skus_1.generateSkusWorkflow)(req.scope).run({
+            input: { product_id: product.id },
+        });
+        generated += result.length;
+    }
+    res.json({ products: needsSku.length, generated });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L2dlbmVyYXRlLWFsbC1za3VzL3JvdXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBWUEsb0JBcUJDO0FBaENELHFEQUFxRTtBQUNyRSx1RUFBMEU7QUFFMUU7Ozs7Ozs7R0FPRztBQUNJLEtBQUssVUFBVSxJQUFJLENBQUMsR0FBK0IsRUFBRSxHQUFtQjtJQUM3RSxNQUFNLEtBQUssR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxpQ0FBeUIsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUVoRSxNQUFNLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxHQUFHLE1BQU0sS0FBSyxDQUFDLEtBQUssQ0FBQztRQUMzQyxNQUFNLEVBQUUsU0FBUztRQUNqQixNQUFNLEVBQUUsQ0FBQyxJQUFJLEVBQUUsY0FBYyxDQUFDO1FBQzlCLFVBQVUsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsRUFBRTtLQUNwQyxDQUFDLENBQUE7SUFDRixNQUFNLFFBQVEsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FDckMsQ0FBQyxDQUFDLENBQUMsUUFBUSxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQ3hDLENBQUE7SUFFRCxJQUFJLFNBQVMsR0FBRyxDQUFDLENBQUE7SUFDakIsS0FBSyxNQUFNLE9BQU8sSUFBSSxRQUFRLEVBQUUsQ0FBQztRQUMvQixNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsTUFBTSxJQUFBLG9DQUFvQixFQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLENBQUM7WUFDM0QsS0FBSyxFQUFFLEVBQUUsVUFBVSxFQUFFLE9BQU8sQ0FBQyxFQUFFLEVBQUU7U0FDbEMsQ0FBQyxDQUFBO1FBQ0YsU0FBUyxJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUE7SUFDNUIsQ0FBQztJQUVELEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDLE1BQU0sRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFBO0FBQ3BELENBQUMifQ==

package/.medusa/server/src/api/admin/ordinant/overview/route.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const utils_1 = require("@medusajs/framework/utils");
+const ordinant_1 = require("../../../../modules/ordinant");
+/**
+ * GET /admin/ordinant/overview
+ *
+ * The Ordinant admin page's display query: every variant SKU in the store
+ * joined with its Ordinant classification state. Medusa is the source of
+ * "which SKUs exist"; Ordinant is the source of "which are classified" —
+ * the join is what makes unclassified SKUs visible at all.
+ */
+async function GET(req, res) {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const ordinant = req.scope.resolve(ordinant_1.ORDINANT_MODULE);
+    const [{ data: products }, { items: classifications }] = await Promise.all([
+        query.graph({
+            entity: "product",
+            fields: ["id", "title", "variants.id", "variants.sku", "variants.title"],
+            pagination: { take: 1000, skip: 0 },
+        }),
+        ordinant.client.listClassifications(undefined, 5000),
+    ]);
+    const bySku = new Map(classifications.map((c) => [c.sku, c]));
+    const rows = [];
+    for (const product of products) {
+        for (const variant of product.variants ?? []) {
+            if (!variant?.sku) {
+                // Surface SKU-less variants instead of hiding them — they can't be
+                // sold until they get a SKU, and the merchant fixes that here.
+                rows.push({
+                    sku: "",
+                    variant_id: variant?.id ?? "",
+                    product_id: product.id,
+                    product_title: product.title,
+                    variant_title: variant?.title ?? null,
+                    status: "needs_sku",
+                    confidence: null,
+                    attributes: null,
+                    notes: null,
+                });
+                continue;
+            }
+            const record = bySku.get(variant.sku);
+            rows.push({
+                sku: variant.sku,
+                variant_id: variant.id ?? "",
+                product_id: product.id,
+                product_title: product.title,
+                variant_title: variant.title ?? null,
+                status: record ? record.status : "unclassified",
+                confidence: record ? record.confidence : null,
+                attributes: record ? record.attributes : null,
+                notes: record?.notes ?? null,
+            });
+        }
+    }
+    rows.sort((a, b) => (a.sku || "~").localeCompare(b.sku || "~"));
+    const summary = {
+        total: rows.length,
+        needs_sku: rows.filter((r) => r.status === "needs_sku").length,
+        unclassified: rows.filter((r) => r.status === "unclassified").length,
+        proposed: rows.filter((r) => r.status === "proposed").length,
+        confirmed: rows.filter((r) => r.status === "confirmed").length,
+    };
+    res.json({ rows, summary });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/admin/ordinant/products/[id]/classify/route.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const classify_product_1 = require("../../../../../../workflows/classify-product");
+/**
+ * POST /admin/ordinant/products/{id}/classify
+ *
+ * Manually (re-)classifies a product's variants — the widget's "Classify"
+ * action, useful for products created before the plugin was installed or
+ * after editing product data.
+ */
+async function POST(req, res) {
+    const { result } = await (0, classify_product_1.classifyProductWorkflow)(req.scope).run({
+        input: { product_id: req.params.id },
+    });
+    res.json({ results: result });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L3Byb2R1Y3RzL1tpZF0vY2xhc3NpZnkvcm91dGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFVQSxvQkFLQztBQWRELG1GQUFzRjtBQUV0Rjs7Ozs7O0dBTUc7QUFDSSxLQUFLLFVBQVUsSUFBSSxDQUFDLEdBQStCLEVBQUUsR0FBbUI7SUFDN0UsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLE1BQU0sSUFBQSwwQ0FBdUIsRUFBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBRyxDQUFDO1FBQzlELEtBQUssRUFBRSxFQUFFLFVBQVUsRUFBRSxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRTtLQUNyQyxDQUFDLENBQUE7SUFDRixHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUE7QUFDL0IsQ0FBQyJ9

package/.medusa/server/src/api/admin/ordinant/products/[id]/generate-skus/route.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const generate_skus_1 = require("../../../../../../workflows/generate-skus");
+const classify_product_1 = require("../../../../../../workflows/classify-product");
+/**
+ * POST /admin/ordinant/products/{id}/generate-skus
+ *
+ * Assigns readable, collision-free SKUs to the product's SKU-less variants,
+ * then immediately classifies the product — hands-off: one action takes a
+ * SKU-less product all the way to a proposed classification, so it lands in
+ * "ready to confirm", never stuck as unclassified needing manual work.
+ * Classification is best-effort (if the module is off or errors, the SKUs
+ * are still written and the product can be classified later).
+ */
+async function POST(req, res) {
+    const { result: generated } = await (0, generate_skus_1.generateSkusWorkflow)(req.scope).run({
+        input: { product_id: req.params.id },
+    });
+    let classified = 0;
+    if (generated.length > 0) {
+        try {
+            const { result } = await (0, classify_product_1.classifyProductWorkflow)(req.scope).run({
+                input: { product_id: req.params.id },
+            });
+            classified = result.filter((r) => !r.error).length;
+        }
+        catch {
+            // SKUs are written; classification can be retried from the dashboard.
+        }
+    }
+    res.json({ generated, classified });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L3Byb2R1Y3RzL1tpZF0vZ2VuZXJhdGUtc2t1cy9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQWNBLG9CQWtCQztBQS9CRCw2RUFBZ0Y7QUFDaEYsbUZBQXNGO0FBRXRGOzs7Ozs7Ozs7R0FTRztBQUNJLEtBQUssVUFBVSxJQUFJLENBQUMsR0FBK0IsRUFBRSxHQUFtQjtJQUM3RSxNQUFNLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxHQUFHLE1BQU0sSUFBQSxvQ0FBb0IsRUFBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBRyxDQUFDO1FBQ3RFLEtBQUssRUFBRSxFQUFFLFVBQVUsRUFBRSxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRTtLQUNyQyxDQUFDLENBQUE7SUFFRixJQUFJLFVBQVUsR0FBRyxDQUFDLENBQUE7SUFDbEIsSUFBSSxTQUFTLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3pCLElBQUksQ0FBQztZQUNILE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxNQUFNLElBQUEsMENBQXVCLEVBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsQ0FBQztnQkFDOUQsS0FBSyxFQUFFLEVBQUUsVUFBVSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFO2FBQ3JDLENBQUMsQ0FBQTtZQUNGLFVBQVUsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxNQUFNLENBQUE7UUFDcEQsQ0FBQztRQUFDLE1BQU0sQ0FBQztZQUNQLHNFQUFzRTtRQUN4RSxDQUFDO0lBQ0gsQ0FBQztJQUVELEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQTtBQUNyQyxDQUFDIn0=

package/.medusa/server/src/api/admin/ordinant/products/[id]/overview/route.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const utils_1 = require("@medusajs/framework/utils");
+const ordinant_1 = require("../../../../../../modules/ordinant");
+/**
+ * GET /admin/ordinant/products/{id}/overview
+ *
+ * The per-product widget's display query. Resolves the product's variant
+ * SKUs SERVER-SIDE via query.graph — the admin widget's injected `data`
+ * prop does not reliably carry variants with SKUs, so we never depend on it.
+ * Joins each SKU with its Ordinant classification state.
+ */
+async function GET(req, res) {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const ordinant = req.scope.resolve(ordinant_1.ORDINANT_MODULE);
+    const { data: products } = await query.graph({
+        entity: "product",
+        fields: ["id", "variants.id", "variants.sku", "variants.title"],
+        filters: { id: req.params.id },
+    });
+    const product = products[0];
+    const allVariants = product?.variants ?? [];
+    const withSku = allVariants.filter((v) => v?.sku);
+    // Only fetch classifications if there are SKUs to look up.
+    let bySku = new Map();
+    if (withSku.length > 0) {
+        const { items } = await ordinant.client.listClassifications(undefined, 5000);
+        const skuSet = new Set(withSku.map((v) => v.sku));
+        bySku = new Map(items.filter((c) => skuSet.has(c.sku)).map((c) => [c.sku, c]));
+    }
+    const rows = allVariants.map((variant) => {
+        if (!variant?.sku) {
+            return {
+                sku: "",
+                variant_id: variant?.id ?? "",
+                variant_title: variant?.title ?? null,
+                status: "needs_sku",
+                confidence: null,
+                attributes: null,
+                notes: null,
+            };
+        }
+        const record = bySku.get(variant.sku);
+        return {
+            sku: variant.sku,
+            variant_id: variant.id,
+            variant_title: variant.title ?? null,
+            status: record ? record.status : "unclassified",
+            confidence: record ? record.confidence : null,
+            attributes: record ? record.attributes : null,
+            notes: record?.notes ?? null,
+        };
+    });
+    const needsSku = rows.some((r) => r.status === "needs_sku");
+    // no_skus: every variant lacks a SKU (nothing classifiable at all).
+    res.json({ rows, no_skus: rows.length > 0 && rows.every((r) => r.status === "needs_sku"), needs_sku: needsSku });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/admin/ordinant/stats/route.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const ordinant_1 = require("../../../../modules/ordinant");
+/**
+ * GET /admin/ordinant/stats
+ *
+ * Proxies the merchant's blocked-order metrics ("stopped illegal orders")
+ * from the engine's durable decision log. The dashboard's impact hero renders
+ * from this. Scoped server-side to the merchant behind the API key.
+ */
+async function GET(req, res) {
+    const ordinant = req.scope.resolve(ordinant_1.ORDINANT_MODULE);
+    const stats = await ordinant.client.blockStats();
+    res.json(stats);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L3N0YXRzL3JvdXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBV0Esa0JBSUM7QUFkRCwyREFBOEQ7QUFHOUQ7Ozs7OztHQU1HO0FBQ0ksS0FBSyxVQUFVLEdBQUcsQ0FBQyxHQUErQixFQUFFLEdBQW1CO0lBQzVFLE1BQU0sUUFBUSxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUF3QiwwQkFBZSxDQUFDLENBQUE7SUFDMUUsTUFBTSxLQUFLLEdBQUcsTUFBTSxRQUFRLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFBO0lBQ2hELEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDakIsQ0FBQyJ9

package/.medusa/server/src/api/admin/ordinant/status/route.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const ordinant_1 = require("../../../../modules/ordinant");
+const client_1 = require("../../../../lib/client");
+/**
+ * GET /admin/ordinant/status
+ *
+ * Lightweight readiness probe for the dashboard. Never throws — a gated or
+ * offline state is a valid answer, not an error. `reason` tells the gate which
+ * message to show:
+ *   - "not_activated" — no API key configured at all
+ *   - "unauthorized"  — a key is set but the engine rejected it (401/403)
+ *   - "unreachable"   — configured, but the engine didn't respond
+ *   - null            — healthy
+ */
+async function GET(req, res) {
+    const ordinant = req.scope.resolve(ordinant_1.ORDINANT_MODULE);
+    if (!ordinant.configured) {
+        res.json({
+            configured: false,
+            engine_reachable: false,
+            ruleset_version: null,
+            reason: "not_activated",
+        });
+        return;
+    }
+    // Configured: probe the engine with the cheapest authenticated call.
+    try {
+        const summary = await ordinant.client.currentRuleset();
+        res.json({
+            configured: true,
+            engine_reachable: true,
+            ruleset_version: summary.version,
+            rule_count: summary.rule_count,
+            reason: null,
+        });
+    }
+    catch (err) {
+        // A key that doesn't authenticate is a different problem (and a different
+        // message) than an engine that's simply down.
+        const httpStatus = err instanceof client_1.OrdinantApiError ? err.status : undefined;
+        const reason = httpStatus === 401 || httpStatus === 403 ? "unauthorized" : "unreachable";
+        res.json({
+            configured: true,
+            engine_reachable: false,
+            ruleset_version: null,
+            reason,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL29yZGluYW50L3N0YXR1cy9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQWdCQSxrQkFtQ0M7QUFsREQsMkRBQThEO0FBRTlELG1EQUF5RDtBQUV6RDs7Ozs7Ozs7OztHQVVHO0FBQ0ksS0FBSyxVQUFVLEdBQUcsQ0FBQyxHQUErQixFQUFFLEdBQW1CO0lBQzVFLE1BQU0sUUFBUSxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUF3QiwwQkFBZSxDQUFDLENBQUE7SUFFMUUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUN6QixHQUFHLENBQUMsSUFBSSxDQUFDO1lBQ1AsVUFBVSxFQUFFLEtBQUs7WUFDakIsZ0JBQWdCLEVBQUUsS0FBSztZQUN2QixlQUFlLEVBQUUsSUFBSTtZQUNyQixNQUFNLEVBQUUsZUFBZTtTQUN4QixDQUFDLENBQUE7UUFDRixPQUFNO0lBQ1IsQ0FBQztJQUVELHFFQUFxRTtJQUNyRSxJQUFJLENBQUM7UUFDSCxNQUFNLE9BQU8sR0FBRyxNQUFNLFFBQVEsQ0FBQyxNQUFNLENBQUMsY0FBYyxFQUFFLENBQUE7UUFDdEQsR0FBRyxDQUFDLElBQUksQ0FBQztZQUNQLFVBQVUsRUFBRSxJQUFJO1lBQ2hCLGdCQUFnQixFQUFFLElBQUk7WUFDdEIsZUFBZSxFQUFFLE9BQU8sQ0FBQyxPQUFPO1lBQ2hDLFVBQVUsRUFBRSxPQUFPLENBQUMsVUFBVTtZQUM5QixNQUFNLEVBQUUsSUFBSTtTQUNiLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1FBQ2IsMEVBQTBFO1FBQzFFLDhDQUE4QztRQUM5QyxNQUFNLFVBQVUsR0FBRyxHQUFHLFlBQVkseUJBQWdCLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQTtRQUMzRSxNQUFNLE1BQU0sR0FBRyxVQUFVLEtBQUssR0FBRyxJQUFJLFVBQVUsS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUMsYUFBYSxDQUFBO1FBQ3hGLEdBQUcsQ0FBQyxJQUFJLENBQUM7WUFDUCxVQUFVLEVBQUUsSUFBSTtZQUNoQixnQkFBZ0IsRUFBRSxLQUFLO1lBQ3ZCLGVBQWUsRUFBRSxJQUFJO1lBQ3JCLE1BQU07U0FDUCxDQUFDLENBQUE7SUFDSixDQUFDO0FBQ0gsQ0FBQyJ9

package/.medusa/server/src/api/middlewares.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("@medusajs/framework/http");
+const validators_1 = require("./store/ordinant/preview/validators");
+exports.default = (0, http_1.defineMiddlewares)({
+    routes: [
+        {
+            matcher: "/store/ordinant/preview",
+            method: "POST",
+            middlewares: [(0, http_1.validateAndTransformBody)(validators_1.PreviewSchema)],
+        },
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBpL21pZGRsZXdhcmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsbURBQXNGO0FBQ3RGLG9FQUFtRTtBQUVuRSxrQkFBZSxJQUFBLHdCQUFpQixFQUFDO0lBQy9CLE1BQU0sRUFBRTtRQUNOO1lBQ0UsT0FBTyxFQUFFLHlCQUF5QjtZQUNsQyxNQUFNLEVBQUUsTUFBTTtZQUNkLFdBQVcsRUFBRSxDQUFDLElBQUEsK0JBQXdCLEVBQUMsMEJBQWEsQ0FBQyxDQUFDO1NBQ3ZEO0tBQ0Y7Q0FDRixDQUFDLENBQUEifQ==