@legenki/print2medusa 0.8.1 → 0.9.2

package/.medusa/server/src/api/admin/printful/prompts/route.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const utils_1 = require("@medusajs/framework/utils");
+const design_1 = require("../../../../utils/design");
+const prompt_1 = require("../../../../utils/prompt");
+/**
+ * Mockup prompts per product.
+ *
+ * A pure read of the database plus string assembly — no Printful call, and no
+ * image generation. The plugin writes prompts; generation happens wherever you
+ * paste them, which is what keeps API keys, rate-limit queues and file storage
+ * out of this repo.
+ */
+async function GET(req, res) {
+    const productModule = req.scope.resolve(utils_1.Modules.PRODUCT);
+    const query = req.query;
+    // An unrecognized style falls back to the first preset rather than
+    // erroring: a mistyped query parameter should still produce prompts.
+    const requested = typeof query.style === "string" ? query.style : undefined;
+    const style = prompt_1.PROMPT_STYLES.some((s) => s.id === requested)
+        ? requested
+        : undefined;
+    const artwork = typeof query.artwork === "string" && query.artwork.trim()
+        ? query.artwork.trim()
+        : undefined;
+    const products = await productModule.listProducts({}, { relations: ["variants"], take: 100 });
+    const items = products
+        .map((product) => {
+        const summary = (0, design_1.summarizeProductDesign)(product.variants ?? []);
+        if (!summary) {
+            // Never enriched by a sync. Omitted rather than listed with no
+            // prompts, which would read as "this product cannot be prompted for".
+            return null;
+        }
+        const prompts = (0, prompt_1.buildProductPrompts)({ design: summary, style, artwork });
+        if (prompts.length === 0) {
+            return null;
+        }
+        return {
+            product_id: product.id,
+            title: product.title,
+            product_class: summary.product_class,
+            prompts,
+        };
+    })
+        .filter((p) => p !== null);
+    res.status(200).json({
+        products: items,
+        styles: prompt_1.PROMPT_STYLES.map((s) => ({ id: s.id, label: s.label })),
+        style: style ?? prompt_1.PROMPT_STYLES[0].id,
+        artwork,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/admin/printful/statistics/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 printful_1 = require("../../../../modules/printful");
+/** Days of history when the caller does not ask for a range. */
+const DEFAULT_DAYS = 30;
+/**
+ * Reports the admin page renders. Asking for only these keeps the response
+ * small; Printful also offers per-product and per-variant breakdowns, which
+ * nothing displays yet and which would be paid for on every page load.
+ */
+const REPORT_TYPES = "profit,total_paid_orders,average_fulfillment_time";
+const isoDate = (d) => d.toISOString().slice(0, 10);
+/**
+ * Sales statistics for the admin page.
+ *
+ * Unlike `/health`, this one genuinely has to call Printful — the figures do
+ * not exist locally. So the failure is handled rather than propagated: an
+ * outage answers `200` with an empty list and a `reason`, not a `500`. The
+ * page fetches three panels independently and a thrown error here would take
+ * out the one screen an owner opens *because* something is wrong.
+ */
+async function GET(req, res) {
+    const printful = req.scope.resolve(printful_1.PRINTFUL_MODULE);
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const query = req.query;
+    const now = new Date();
+    const from = new Date(now.getTime() - DEFAULT_DAYS * 24 * 60 * 60 * 1000);
+    const dateFrom = typeof query.date_from === "string" && query.date_from
+        ? query.date_from
+        : isoDate(from);
+    const dateTo = typeof query.date_to === "string" && query.date_to
+        ? query.date_to
+        : isoDate(now);
+    try {
+        const client = await printful.getClient();
+        const statistics = await client.getStatistics({
+            dateFrom,
+            dateTo,
+            reportTypes: REPORT_TYPES,
+        });
+        res.status(200).json({ statistics, date_from: dateFrom, date_to: dateTo });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error(`Printful statistics unavailable: ${message}`);
+        // 200 with an empty list, not an error status: the page treats this as
+        // "nothing to show" and keeps rendering sync history and webhook health,
+        // which are exactly what an operator needs during a Printful outage.
+        res.status(200).json({
+            statistics: [],
+            date_from: dateFrom,
+            date_to: dateTo,
+            reason: "printful_unreachable",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL3ByaW50ZnVsL3N0YXRpc3RpY3Mvcm91dGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUEwQkEsa0JBd0NDO0FBakVELHFEQUFxRTtBQUNyRSwyREFBOEQ7QUFHOUQsZ0VBQWdFO0FBQ2hFLE1BQU0sWUFBWSxHQUFHLEVBQUUsQ0FBQTtBQUV2Qjs7OztHQUlHO0FBQ0gsTUFBTSxZQUFZLEdBQUcsbURBQW1ELENBQUE7QUFFeEUsTUFBTSxPQUFPLEdBQUcsQ0FBQyxDQUFPLEVBQVUsRUFBRSxDQUFDLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFBO0FBRWpFOzs7Ozs7OztHQVFHO0FBQ0ksS0FBSyxVQUFVLEdBQUcsQ0FBQyxHQUFrQixFQUFFLEdBQW1CO0lBQy9ELE1BQU0sUUFBUSxHQUEwQixHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQywwQkFBZSxDQUFDLENBQUE7SUFDMUUsTUFBTSxNQUFNLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsaUNBQXlCLENBQUMsTUFBTSxDQUFDLENBQUE7SUFFbEUsTUFBTSxLQUFLLEdBQUcsR0FBRyxDQUFDLEtBQWdDLENBQUE7SUFDbEQsTUFBTSxHQUFHLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQTtJQUN0QixNQUFNLElBQUksR0FBRyxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLEdBQUcsWUFBWSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxDQUFBO0lBRXpFLE1BQU0sUUFBUSxHQUNaLE9BQU8sS0FBSyxDQUFDLFNBQVMsS0FBSyxRQUFRLElBQUksS0FBSyxDQUFDLFNBQVM7UUFDcEQsQ0FBQyxDQUFDLEtBQUssQ0FBQyxTQUFTO1FBQ2pCLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDbkIsTUFBTSxNQUFNLEdBQ1YsT0FBTyxLQUFLLENBQUMsT0FBTyxLQUFLLFFBQVEsSUFBSSxLQUFLLENBQUMsT0FBTztRQUNoRCxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU87UUFDZixDQUFDLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBRWxCLElBQUksQ0FBQztRQUNILE1BQU0sTUFBTSxHQUFHLE1BQU0sUUFBUSxDQUFDLFNBQVMsRUFBRSxDQUFBO1FBQ3pDLE1BQU0sVUFBVSxHQUFHLE1BQU0sTUFBTSxDQUFDLGFBQWEsQ0FBQztZQUM1QyxRQUFRO1lBQ1IsTUFBTTtZQUNOLFdBQVcsRUFBRSxZQUFZO1NBQzFCLENBQUMsQ0FBQTtRQUVGLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUE7SUFDNUUsQ0FBQztJQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7UUFDYixNQUFNLE9BQU8sR0FBRyxHQUFHLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDaEUsTUFBTSxDQUFDLEtBQUssQ0FBQyxvQ0FBb0MsT0FBTyxFQUFFLENBQUMsQ0FBQTtRQUUzRCx1RUFBdUU7UUFDdkUseUVBQXlFO1FBQ3pFLHFFQUFxRTtRQUNyRSxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztZQUNuQixVQUFVLEVBQUUsRUFBRTtZQUNkLFNBQVMsRUFBRSxRQUFRO1lBQ25CLE9BQU8sRUFBRSxNQUFNO1lBQ2YsTUFBTSxFQUFFLHNCQUFzQjtTQUMvQixDQUFDLENBQUE7SUFDSixDQUFDO0FBQ0gsQ0FBQyJ9

package/.medusa/server/src/api/admin/printful/sync/clear/route.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const printful_1 = require("../../../../../modules/printful");
+const clear_sync_1 = require("../../../../../utils/clear-sync");
+/**
+ * Clear a sync that is stuck in `running`.
+ *
+ * Nested under `sync/` rather than living at its own top-level path because it
+ * acts on exactly the resource `POST /admin/printful/sync` claims — the two
+ * belong together, and the 409 body from that route is what sends an operator
+ * here. POST, not DELETE: this does not remove the row, it transitions it to a
+ * terminal state and writes an audit marker.
+ *
+ * This closes the limit recorded in 0.4.0: after a crash the log stays
+ * `running` and nothing reclaims it until the next sync attempt, so with the
+ * default `syncStaleMinutes: 60` the catalog is blocked for up to an hour with
+ * no way to intervene.
+ *
+ * It deliberately does not just call `reapStaleSyncLogs(0)`. That would clear
+ * any running sync unconditionally, including a healthy one mid-catalog, and
+ * would stamp the row with the same `stale_running` marker the timeout reaper
+ * uses — making a human intervention indistinguishable from an automatic
+ * recovery in the audit trail. `planSyncClear` owns both decisions.
+ */
+async function POST(req, res) {
+    const printful = req.scope.resolve(printful_1.PRINTFUL_MODULE);
+    const options = await printful.getOptions();
+    const body = (req.body ?? {});
+    const confirmation = typeof body.confirm === "string" ? body.confirm : null;
+    const running = await printful.getRunningSyncLog();
+    const decision = (0, clear_sync_1.planSyncClear)({
+        log: running,
+        confirmation,
+        staleMinutes: options.syncStaleMinutes ?? 60,
+    });
+    if (!decision.allowed) {
+        if (decision.reason === "nothing_running") {
+            // Not an error. The page asked to clear a stuck sync and there is no
+            // sync to clear, which is the state the operator wanted.
+            res.status(200).json({
+                cleared: false,
+                reason: "nothing_running",
+                message: "No Printful sync is running",
+            });
+            return;
+        }
+        if (decision.reason === "unconfirmed") {
+            res.status(400).json({
+                cleared: false,
+                reason: "unconfirmed",
+                message: `Clearing a sync is destructive. Send { "confirm": "${clear_sync_1.CLEAR_SYNC_CONFIRMATION}" } to proceed.`,
+                sync_id: decision.sync_id,
+            });
+            return;
+        }
+        // `alive`: the heartbeat says this sync is still running. 409 matches the
+        // 409 that POST /admin/printful/sync returns for the same condition — a
+        // sync is holding the claim and the caller cannot have it.
+        res.status(409).json({
+            cleared: false,
+            reason: "alive",
+            message: "This sync is still sending heartbeats. Clearing it would mark a live sync as failed while it keeps writing.",
+            sync_id: decision.sync_id,
+            silent_minutes: decision.silent_minutes,
+        });
+        return;
+    }
+    // Conditional on the heartbeat we just read. If the sync emitted one more
+    // between that read and this write, it was never dead and the update matches
+    // nothing — see clearStuckSyncLog.
+    const cleared = await printful.clearStuckSyncLog({
+        id: decision.sync_id,
+        observedHeartbeatAt: running?.heartbeat_at ?? null,
+        errorMessage: decision.error_message,
+    });
+    if (!cleared) {
+        res.status(409).json({
+            cleared: false,
+            reason: "alive",
+            message: "This sync sent a heartbeat while the request was being handled, so it is still alive and was left running.",
+            sync_id: decision.sync_id,
+        });
+        return;
+    }
+    res.status(200).json({
+        cleared: true,
+        sync_id: decision.sync_id,
+        error_message: decision.error_message,
+        silent_minutes: decision.silent_minutes,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/printful/service.js

@@ -299,6 +299,44 @@ class PrintfulModuleService extends (0, utils_1.MedusaService)({
         const [log] = await this.listPrintfulSyncLogs({ status: "running" });
         return log ?? null;
     }
+    /**
+     * Clear a specific stuck sync on an operator's instruction.
+     *
+     * Separate from `reapStaleSyncLogs` on purpose. That one is the timeout
+     * reaper: it selects its own victims by age and stamps them `stale_running`.
+     * This one clears exactly the row the operator was looking at and records a
+     * marker naming them as the cause, so the two are distinguishable in the log
+     * long after the fact.
+     *
+     * The `heartbeat_at` predicate makes the write conditional on the row still
+     * being as stale as the caller observed. Between the route's read and this
+     * write, a sync everyone believed dead can emit one more heartbeat; without
+     * this predicate that row would be marked `failed` underneath a live
+     * process. With it, the late heartbeat moves `heartbeat_at` past the
+     * observed value, the update matches nothing, and the caller is told the
+     * sync is alive after all.
+     *
+     * Returns true when a row was actually cleared.
+     */
+    async clearStuckSyncLog(input) {
+        const stillStale = await this.listPrintfulSyncLogs({
+            id: input.id,
+            status: "running",
+            heartbeat_at: input.observedHeartbeatAt
+                ? { $lte: input.observedHeartbeatAt }
+                : null,
+        });
+        if (stillStale.length === 0) {
+            return false;
+        }
+        await this.updatePrintfulSyncLogs({
+            id: input.id,
+            status: "failed",
+            error_message: input.errorMessage,
+            finished_at: new Date(),
+        });
+        return true;
+    }
     /** Refresh the claim so it is not reaped, and report progress. */
     async heartbeatSyncLog(id, progress = {}) {
         return this.updatePrintfulSyncLogs({
@@ -309,4 +347,4 @@ class PrintfulModuleService extends (0, utils_1.MedusaService)({
     }
 }
 exports.default = PrintfulModuleService;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/printful/service.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/printful/service.ts"],"names":[],"mappings":";;;;;;AAgDA,4CAIC;AAaD,gCAGC;AAiBD,8CA2BC;AAhHD,qDAAyD;AACzD,mCAAmC;AACnC,iEAA4D;AAE5D,uFAA4D;AAC5D,2FAAgE;AAChE,mFAAwD;AACxD,2FAAgE;AAChE,6FAAkE;AA2BlE;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,SAAS,CAAA;AAElD,gEAAgE;AACnD,QAAA,oBAAoB,GAAG,EAAE,CAAA;AAEtC,kEAAkE;AAClE,SAAgB,gBAAgB,CAAC,QAAgB;IAC/C,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAA;IAClC,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAA;IACpC,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAA;AAClE,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CAAC,eAAuB;IAChD,MAAM,MAAM,GAAG,IAAA,mBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,EAAE,CAAA;IAC5E,OAAO,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;AAC9B,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,iBAAiB,CAAC,GAAY;IAC5C,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QACpC,OAAO,KAAK,CAAA;IACd,CAAC;IACD,MAAM,CAAC,GAAG,GAKT,CAAA;IACD,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QACvB,OAAO,IAAI,CAAA;IACb,CAAC;IACD,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACjE,OAAO,IAAI,CAAA;IACb,CAAC;IACD,IACE,CAAC,CAAC,IAAI,KAAK,cAAc;QACzB,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ;QAC7B,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,EAC5C,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IACD,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG,EAAE,CAAC;QAC/B,OAAO,iBAAiB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;IACnC,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,qBAAsB,SAAQ,IAAA,qBAAa,EAAC;IAChD,mBAAmB,EAAnB,+BAAmB;IACnB,mBAAmB,EAAnB,+BAAmB;IACnB,eAAe,EAAf,2BAAe;IACf,iBAAiB,EAAjB,6BAAiB;IACjB,oBAAoB,EAApB,gCAAoB;CACrB,CAAC;IAMA,YACE,SAA+B,EAC/B,OAA+B;QAE/B,sCAAsC;QACtC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAA;QATX,YAAO,GAA0B,IAAI,CAAA;QAU7C,IAAI,CAAC,QAAQ,GAAG,OAAO,IAAK,EAA4B,CAAA;IAC1D,CAAC;IAED,KAAK,CAAC,UAAU;QACd,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAED,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC;gBAC7B,MAAM,IAAI,KAAK,CACb,8EAA8E,CAC/E,CAAA;YACH,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,gCAAc,CAAC;gBAChC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ;gBAChC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;aAC/B,CAAC,CAAA;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;IAED,KAAK,CAAC,UAAU;QACd,OAAO,IAAI,CAAC,QAAQ,EAAE,OAAO,IAAI,SAAS,CAAA;IAC5C,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,aAAqB;QACzC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAA;QACvC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC;YACjD,iBAAiB,EAAE,OAAO;YAC1B,wBAAwB,EAAE,MAAM,CAAC,aAAa,CAAC;SAChD,CAAC,CAAA;QACF,OAAO,IAAI,IAAI,IAAI,CAAA;IACrB,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,aAAqB;QACzC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAA;QACvC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC;YACjD,iBAAiB,EAAE,OAAO;YAC1B,wBAAwB,EAAE,MAAM,CAAC,aAAa,CAAC;SAChD,CAAC,CAAA;QACF,OAAO,IAAI,IAAI,IAAI,CAAA;IACrB,CAAC;IAED,KAAK,CAAC,yBAAyB,CAAC,eAAuB;QACrD,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC;YACjD,iBAAiB,EAAE,eAAe;SACnC,CAAC,CAAA;QACF,OAAO,IAAI,IAAI,IAAI,CAAA;IACrB,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,aAAqB;QACvC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC;YAC/C,eAAe,EAAE,aAAa;SAC/B,CAAC,CAAA;QACF,OAAO,IAAI,IAAI,IAAI,CAAA;IACrB,CAAC;IAED,8EAA8E;IAC9E,KAAK,CAAC,yBAAyB,CAAC,eAAuB;QACrD,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC;YAC/C,iBAAiB,EAAE,MAAM,CAAC,eAAe,CAAC;SAC3C,CAAC,CAAA;QACF,OAAO,IAAI,IAAI,IAAI,CAAA;IACrB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,kBAAkB,CAAC,KAOxB;QACC,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,2BAA2B,CAAC;gBAC5C,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;gBAC1C,oBAAoB,EAAE,KAAK,CAAC,oBAAoB,IAAI,IAAI;gBACxD,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,UAAU;gBAClC,QAAQ,EAAE,CAAC;gBACX,aAAa,EAAE,IAAI,IAAI,EAAE;aAC1B,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAA;YACb,CAAC;YACD,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,OAAe;QACpC,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAA;QAC3E,OAAO,KAAK,IAAI,IAAI,CAAA;IACtB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,oBAAoB,CAAC,KAAK,GAAG,EAAE;QACnC,OAAO,IAAI,CAAC,yBAAyB,CACnC;YACE,MAAM,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC;YAChC,aAAa,EAAE,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,EAAE;YACnC,QAAQ,EAAE,EAAE,GAAG,EAAE,4BAAoB,EAAE;SACxC,EACD,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,EAAE,CACjD,CAAA;IACH,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,aAAa,CACjB,eAAuB,EACvB,EAAoB;QAEpB,MAAM,GAAG,GAAG,UAAU,CAAC,eAAe,CAAC,CAAA;QACvC,OAAO,IAAI,CAAC,eAAe,CAAC,WAAW,CACrC,KAAK,EAAE,SAAyB,EAAE,EAAE;YAClC,MAAM,SAAS,CAAC,OAAO,CAAC,iCAAiC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;YACjE,OAAO,MAAM,EAAE,EAAE,CAAA;QACnB,CAAC,CACF,CAAA;IACH,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,cAAc,CAAC,aAAqB;QAIxC,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC;gBAC/C,eAAe,EAAE,aAAa;gBAC9B,iBAAiB,EAAE,iCAAyB;gBAC5C,WAAW,EAAE,aAAa;gBAC1B,MAAM,EAAE,SAAS;aAClB,CAAC,CAAA;YACF,OAAO,IAAI,CAAA;QACb,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAA;YACb,CAAC;YACD,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAC1C,EAAE,EACF,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,CAC3C,CAAA;QACD,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;IACxB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,iBAAiB,CAAC,YAAoB;QAC1C,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,GAAG,EAAE,GAAG,IAAI,CAAC,CAAA;QAC9D,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC;YAC5C,MAAM,EAAE,SAAS;YACjB,GAAG,EAAE,CAAC,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;SACjE,CAAC,CAAA;QAEF,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YACxB,MAAM,IAAI,CAAC,sBAAsB,CAAC;gBAChC,EAAE,EAAE,GAAG,CAAC,EAAE;gBACV,MAAM,EAAE,QAAQ;gBAChB,aAAa,EAAE,eAAe;gBAC9B,WAAW,EAAE,IAAI,IAAI,EAAE;aACxB,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,KAAK,CAAC,MAAM,CAAA;IACrB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,YAAY,CAAC,YAAoB;QACrC,MAAM,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAA;QAE1C,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAA;QACtB,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC;gBACvC,MAAM,EAAE,SAAS;gBACjB,UAAU,EAAE,GAAG;gBACf,YAAY,EAAE,GAAG;gBACjB,gBAAgB,EAAE,CAAC;gBACnB,gBAAgB,EAAE,CAAC;gBACnB,eAAe,EAAE,CAAC;gBAClB,kBAAkB,EAAE,CAAC;gBACrB,cAAc,EAAE,CAAC;aAClB,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAA;YACb,CAAC;YACD,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;IAED,4DAA4D;IAC5D,KAAK,CAAC,iBAAiB;QACrB,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAA;QACpE,OAAO,GAAG,IAAI,IAAI,CAAA;IACpB,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,iBAAiB,CAAC,KAKvB;QACC,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC;YACjD,EAAE,EAAE,KAAK,CAAC,EAAE;YACZ,MAAM,EAAE,SAAS;YACjB,YAAY,EAAE,KAAK,CAAC,mBAAmB;gBACrC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,mBAAmB,EAAE;gBACrC,CAAC,CAAC,IAAI;SACT,CAAC,CAAA;QAEF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,KAAK,CAAA;QACd,CAAC;QAED,MAAM,IAAI,CAAC,sBAAsB,CAAC;YAChC,EAAE,EAAE,KAAK,CAAC,EAAE;YACZ,MAAM,EAAE,QAAQ;YAChB,aAAa,EAAE,KAAK,CAAC,YAAY;YACjC,WAAW,EAAE,IAAI,IAAI,EAAE;SACxB,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED,kEAAkE;IAClE,KAAK,CAAC,gBAAgB,CACpB,EAAU,EACV,WAAqE,EAAE;QAEvE,OAAO,IAAI,CAAC,sBAAsB,CAAC;YACjC,EAAE;YACF,YAAY,EAAE,IAAI,IAAI,EAAE;YACxB,GAAG,QAAQ;SACZ,CAAC,CAAA;IACJ,CAAC;CACF;AAED,kBAAe,qBAAqB,CAAA"}

package/.medusa/server/src/utils/bundle.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Merch bundles: one Medusa product that stands for several Printful ones.
+ *
+ * Printful has no notion of a bundle — it fulfils individual items. So a
+ * bundle is a Medusa product whose variant records which member variants it
+ * contains, and order creation expands it back into those members.
+ *
+ * **Why expansion is mandatory rather than a nicety.** `create-printful-order`
+ * resolves one order line to one Printful item via `item.variant_id`. A bundle
+ * left unexpanded therefore ships a single thing where the customer bought
+ * three — or, if the bundle variant has no Printful link at all, the order is
+ * skipped as `no_printful_items` and nothing ships.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUNDLE_MEMBERS_KEY = void 0;
+exports.bundleMembersOf = bundleMembersOf;
+exports.isBundleLine = isBundleLine;
+exports.expandOrderLines = expandOrderLines;
+exports.medusaLineIdFor = medusaLineIdFor;
+exports.planBundlePass = planBundlePass;
+exports.planBundlePublication = planBundlePublication;
+exports.planBundleAvailability = planBundleAvailability;
+const stock_1 = require("./stock");
+/** Statuses meaning a variant cannot be ordered. Mirrors `stock.ts`. */
+const UNAVAILABLE = new Set([
+    "out_of_stock",
+    "temporary_out_of_stock",
+    "discontinued",
+]);
+/** Where a bundle's composition lives, on the variant and on the order line. */
+exports.BUNDLE_MEMBERS_KEY = "printful_bundle_members";
+/**
+ * The members recorded on a line, or nothing.
+ *
+ * Metadata is free-form JSON, so this validates rather than trusts: something
+ * else writing a string to this key must not crash order creation.
+ */
+function bundleMembersOf(line) {
+    const raw = (line?.metadata ?? {})[exports.BUNDLE_MEMBERS_KEY];
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const members = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const variantId = entry.variant_id;
+        if (typeof variantId !== "string" || !variantId.trim()) {
+            continue;
+        }
+        const quantity = Number(entry.quantity ?? 1);
+        members.push({
+            variant_id: variantId,
+            quantity: Number.isFinite(quantity) && quantity > 0 ? quantity : 1,
+        });
+    }
+    return members;
+}
+/**
+ * Whether a line stands for several products.
+ *
+ * A line whose member list is empty is *not* a bundle. Treating it as one
+ * would expand it to nothing, and an order of nothing looks identical to an
+ * order Printful was never asked about. Left alone, it flows through the
+ * ordinary unresolved-variant path, which reports it.
+ */
+function isBundleLine(line) {
+    return bundleMembersOf(line).length > 0;
+}
+/**
+ * Replace every bundle line with the lines it stands for.
+ *
+ * Composition is read from the line's own metadata, captured when the customer
+ * bought — never looked up live. A merchant who edits a bundle after a sale
+ * must not change what an already-placed order ships.
+ *
+ * Ordinary lines pass through untouched and keep their position, so a cart
+ * mixing bundles and singles reaches Printful in the order it was built.
+ */
+function expandOrderLines(lines) {
+    const out = [];
+    for (const line of lines) {
+        const members = bundleMembersOf(line);
+        if (members.length === 0) {
+            out.push(line);
+            continue;
+        }
+        for (const member of members) {
+            out.push({
+                // Synthesised, but stable and traceable: two bundles in one cart
+                // cannot collide, and the id says where the line came from.
+                id: `${line.id}::${member.variant_id}`,
+                variant_id: member.variant_id,
+                title: line.title,
+                // Two bundles each holding two stickers is four stickers. Dropping
+                // this multiplication ships a customer half their order.
+                quantity: (member.quantity ?? 1) * Number(line.quantity || 1),
+                metadata: {},
+                bundle_line_id: line.id,
+            });
+        }
+    }
+    return out;
+}
+/** Separates the bundle line id from the member variant id in a synthetic id. */
+const SYNTHETIC_SEPARATOR = "::";
+/**
+ * The Medusa line an `external_id` from Printful refers to.
+ *
+ * Expansion sends synthetic ids like `ordli_abc::variant_tee` as `external_id`,
+ * because Printful needs each item distinguishable and two members of one
+ * bundle would otherwise share the bundle line's id.
+ *
+ * Fulfillment reads those ids back to decide which Medusa line a parcel filled.
+ * Without this, a bundle's items resolve to an id no Medusa line has, every
+ * parcel clamps to zero open quantity, and the order is never marked shipped.
+ *
+ * A member id maps back to the *bundle* line, since that is the line the
+ * customer bought and the only one Medusa can fulfil.
+ */
+function medusaLineIdFor(externalId) {
+    const at = externalId.indexOf(SYNTHETIC_SEPARATOR);
+    return at === -1 ? externalId : externalId.slice(0, at);
+}
+/**
+ * Which bundle products the sync should rewrite, and to what.
+ *
+ * Bundles are invisible to the ordinary sync: they have no Printful product of
+ * their own, so no `sync_product` ever names them and the per-product loop
+ * never reaches them. Without this pass a bundle stays on sale after a member
+ * sells out, and every such order fails at Printful.
+ *
+ * Availability is read from the member variants passed in, not from the bundle
+ * — the bundle variant has no Printful status of its own to read.
+ *
+ * Returns only products that need writing, so a sync over a catalogue with no
+ * bundle changes issues no updates at all.
+ */
+function planBundlePass(input) {
+    const writes = [];
+    for (const bundle of input.bundles) {
+        const memberIds = (bundle.variants ?? []).flatMap((v) => bundleMembersOf({ id: v.id, quantity: 1, metadata: v.metadata }).map((m) => m.variant_id));
+        if (memberIds.length === 0) {
+            continue;
+        }
+        // A member variant the sync could not load is left out of the decision
+        // rather than counted as sold out: a failed lookup is not evidence that
+        // Printful ran out of anything, and drafting on it would hide a live
+        // bundle on a transient error.
+        const known = memberIds
+            .map((id) => input.variantsById.get(id))
+            .filter((v) => !!v);
+        // Knowing nothing about any member is not the same as knowing they are all
+        // in stock. Left to fall through, a bundle drafted for a sellout would be
+        // republished on the strength of a lookup that simply failed.
+        if (known.length === 0) {
+            continue;
+        }
+        const plan = planBundlePublication({
+            members: known,
+            currentStatus: bundle.status === "published" ? "published" : "draft",
+            currentMetadata: (bundle.metadata ?? {}),
+        });
+        if (!plan.changed) {
+            continue;
+        }
+        writes.push({
+            product_id: bundle.id,
+            status: plan.status,
+            metadata: plan.metadata,
+            missing: memberIds.filter((id) => {
+                const status = input.variantsById.get(id)?.metadata?.printful_availability_status;
+                return typeof status === "string" && UNAVAILABLE.has(status);
+            }),
+        });
+    }
+    return writes;
+}
+/**
+ * Whether a bundle should be published, from the stock of its members.
+ *
+ * Reuses `resolvePublication` so a bundle obeys the same ownership rule as
+ * every other product: the plugin undoes only unpublishes it performed, and a
+ * draft the merchant made themselves is left alone however available Printful
+ * says the members are.
+ *
+ * What differs is the threshold. `planStockActions` drafts a product only when
+ * *every* variant is gone, because any remaining variant is still sellable. A
+ * bundle is a promise to ship all of it, so one missing member already breaks
+ * the promise.
+ *
+ * A bundle with no members recorded is left untouched — that is a bundle the
+ * merchant has not finished configuring, not one that sold out.
+ */
+function planBundlePublication(input) {
+    const availability = planBundleAvailability(input.members.map((m) => m?.metadata ?? {}));
+    // One missing member is enough. A bundle with no members recorded has no
+    // unavailable ones either, so it falls through as available — an
+    // unconfigured bundle is not a sold-out one.
+    const allUnavailable = availability.unavailableCount > 0;
+    return (0, stock_1.resolvePublication)({
+        plan: {
+            allUnavailable,
+            status: allUnavailable ? "draft" : "published",
+            hasDiscontinued: false,
+            variantAvailability: {},
+        },
+        currentStatus: input.currentStatus,
+        currentMetadata: input.currentMetadata,
+    });
+}
+/**
+ * Whether a bundle can be sold, from the availability of its members.
+ *
+ * A bundle is a promise to ship all of it, so one sold-out member makes the
+ * promise unkeepable however available the rest are.
+ *
+ * Reads `printful_availability_status`, which the sync already writes — no new
+ * source of truth, and no second place to keep in step with Printful.
+ *
+ * An unknown status counts as available, matching `planStockActions`: the
+ * unavailable set is a closed list, and a bundle must not be stricter about a
+ * status than the member product itself is.
+ */
+function planBundleAvailability(members) {
+    let unavailable = 0;
+    for (const member of members) {
+        const status = member?.printful_availability_status;
+        if (typeof status === "string" && UNAVAILABLE.has(status)) {
+            unavailable += 1;
+        }
+    }
+    return {
+        // An empty bundle is unavailable rather than vacuously available: there is
+        // nothing to ship, which is not the same as everything being in stock.
+        available: members.length > 0 && unavailable === 0,
+        memberCount: members.length,
+        unavailableCount: unavailable,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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