@legenki/print2medusa 0.1.0 → 0.3.0

package/.medusa/server/src/modules/printful/migrations/Migration20260731000000.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20260731000000 = void 0;
+const migrations_1 = require("@medusajs/framework/mikro-orm/migrations");
+class Migration20260731000000 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`
+      create table if not exists "printful_webhook_event" (
+        "id" text not null,
+        "event_id" text not null,
+        "type" text not null,
+        "printful_order_id" text not null,
+        "printful_shipment_id" text null,
+        "payload" jsonb not null default '{}'::jsonb,
+        "status" text not null default 'received',
+        "attempts" integer not null default 0,
+        "next_retry_at" timestamptz null,
+        "processed_at" timestamptz null,
+        "error_message" text null,
+        "created_at" timestamptz not null default now(),
+        "updated_at" timestamptz not null default now(),
+        "deleted_at" timestamptz null,
+        constraint "printful_webhook_event_pkey" primary key ("id")
+      );
+    `);
+        this.addSql(`
+      create unique index if not exists "IDX_printful_webhook_event_event_id"
+      on "printful_webhook_event" ("event_id")
+      where deleted_at is null;
+    `);
+        this.addSql(`
+      create index if not exists "IDX_printful_webhook_event_order"
+      on "printful_webhook_event" ("printful_order_id")
+      where deleted_at is null;
+    `);
+        this.addSql(`
+      create index if not exists "IDX_printful_webhook_event_shipment"
+      on "printful_webhook_event" ("printful_shipment_id")
+      where deleted_at is null;
+    `);
+        this.addSql(`
+      create index if not exists "IDX_printful_webhook_event_retry"
+      on "printful_webhook_event" ("status", "next_retry_at")
+      where deleted_at is null;
+    `);
+        // Webhooks arrive knowing only the Printful order id, so this lookup must
+        // not be a sequential scan. The sentinel written by claimOrderLink is
+        // excluded: without that exclusion, two concurrent claims would collide
+        // here instead of on medusa_order_id, breaking insert-first protection.
+        this.addSql(`
+      create unique index if not exists "IDX_printful_order_link_printful"
+      on "printful_order_link" ("printful_order_id")
+      where deleted_at is null and "printful_order_id" <> 'pending';
+    `);
+    }
+    async down() {
+        this.addSql(`drop index if exists "IDX_printful_order_link_printful";`);
+        this.addSql(`drop table if exists "printful_webhook_event" cascade;`);
+    }
+}
+exports.Migration20260731000000 = Migration20260731000000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNjA3MzEwMDAwMDAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wcmludGZ1bC9taWdyYXRpb25zL01pZ3JhdGlvbjIwMjYwNzMxMDAwMDAwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHlFQUFvRTtBQUVwRSxNQUFhLHVCQUF3QixTQUFRLHNCQUFTO0lBQzNDLEtBQUssQ0FBQyxFQUFFO1FBQ2YsSUFBSSxDQUFDLE1BQU0sQ0FBQzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0tBa0JYLENBQUMsQ0FBQTtRQUNGLElBQUksQ0FBQyxNQUFNLENBQUM7Ozs7S0FJWCxDQUFDLENBQUE7UUFDRixJQUFJLENBQUMsTUFBTSxDQUFDOzs7O0tBSVgsQ0FBQyxDQUFBO1FBQ0YsSUFBSSxDQUFDLE1BQU0sQ0FBQzs7OztLQUlYLENBQUMsQ0FBQTtRQUNGLElBQUksQ0FBQyxNQUFNLENBQUM7Ozs7S0FJWCxDQUFDLENBQUE7UUFFRiwwRUFBMEU7UUFDMUUsc0VBQXNFO1FBQ3RFLHdFQUF3RTtRQUN4RSx3RUFBd0U7UUFDeEUsSUFBSSxDQUFDLE1BQU0sQ0FBQzs7OztLQUlYLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFFUSxLQUFLLENBQUMsSUFBSTtRQUNqQixJQUFJLENBQUMsTUFBTSxDQUFDLDBEQUEwRCxDQUFDLENBQUE7UUFDdkUsSUFBSSxDQUFDLE1BQU0sQ0FBQyx3REFBd0QsQ0FBQyxDQUFBO0lBQ3ZFLENBQUM7Q0FDRjtBQXpERCwwREF5REMifQ==

package/.medusa/server/src/modules/printful/models/printful-webhook-event.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const PrintfulWebhookEvent = utils_1.model.define("printful_webhook_event", {
+    id: utils_1.model.id().primaryKey(),
+    event_id: utils_1.model.text().unique(),
+    type: utils_1.model.text(),
+    printful_order_id: utils_1.model.text(),
+    printful_shipment_id: utils_1.model.text().nullable(),
+    payload: utils_1.model.json(),
+    status: utils_1.model.text().default("received"),
+    attempts: utils_1.model.number().default(0),
+    next_retry_at: utils_1.model.dateTime().nullable(),
+    processed_at: utils_1.model.dateTime().nullable(),
+    error_message: utils_1.model.text().nullable(),
+});
+exports.default = PrintfulWebhookEvent;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbnRmdWwtd2ViaG9vay1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tb2R1bGVzL3ByaW50ZnVsL21vZGVscy9wcmludGZ1bC13ZWJob29rLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEscURBQWlEO0FBRWpELE1BQU0sb0JBQW9CLEdBQUcsYUFBSyxDQUFDLE1BQU0sQ0FBQyx3QkFBd0IsRUFBRTtJQUNsRSxFQUFFLEVBQUUsYUFBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLFVBQVUsRUFBRTtJQUMzQixRQUFRLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRSxDQUFDLE1BQU0sRUFBRTtJQUMvQixJQUFJLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRTtJQUNsQixpQkFBaUIsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFO0lBQy9CLG9CQUFvQixFQUFFLGFBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxRQUFRLEVBQUU7SUFDN0MsT0FBTyxFQUFFLGFBQUssQ0FBQyxJQUFJLEVBQUU7SUFDckIsTUFBTSxFQUFFLGFBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDO0lBQ3hDLFFBQVEsRUFBRSxhQUFLLENBQUMsTUFBTSxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUNuQyxhQUFhLEVBQUUsYUFBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUMxQyxZQUFZLEVBQUUsYUFBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUN6QyxhQUFhLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRSxDQUFDLFFBQVEsRUFBRTtDQUN2QyxDQUFDLENBQUE7QUFFRixrQkFBZSxvQkFBb0IsQ0FBQSJ9

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

@@ -3,20 +3,63 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PENDING_PRINTFUL_ORDER_ID = void 0;
+exports.MAX_WEBHOOK_ATTEMPTS = exports.PENDING_PRINTFUL_ORDER_ID = void 0;
+exports.nextRetryDelayMs = nextRetryDelayMs;
+exports.lockKeyFor = lockKeyFor;
 exports.isUniqueViolation = isUniqueViolation;
 const utils_1 = require("@medusajs/framework/utils");
+const crypto_1 = require("crypto");
 const printful_client_1 = require("../../utils/printful-client");
 const printful_order_link_1 = __importDefault(require("./models/printful-order-link"));
 const printful_product_link_1 = __importDefault(require("./models/printful-product-link"));
 const printful_sync_log_1 = __importDefault(require("./models/printful-sync-log"));
 const printful_variant_link_1 = __importDefault(require("./models/printful-variant-link"));
-/** Sentinel stored in a placeholder link before the Printful order exists. */
+const printful_webhook_event_1 = __importDefault(require("./models/printful-webhook-event"));
+/**
+ * Sentinel stored in a placeholder link before the Printful order exists.
+ *
+ * Migration20260731000000 excludes this exact value from the unique index on
+ * printful_order_id. Changing it without updating that migration reintroduces
+ * the concurrent-claim race; tests/order-link.test.ts guards the pairing.
+ */
 exports.PENDING_PRINTFUL_ORDER_ID = "pending";
+/** Attempts before an event is parked as permanently failed. */
+exports.MAX_WEBHOOK_ATTEMPTS = 20;
+/** Backoff: 5 minutes doubling per attempt, capped at 6 hours. */
+function nextRetryDelayMs(attempts) {
+    const FIVE_MINUTES = 5 * 60 * 1000;
+    const SIX_HOURS = 6 * 60 * 60 * 1000;
+    return Math.min(FIVE_MINUTES * Math.pow(2, attempts), SIX_HOURS);
+}
+/**
+ * Stable 32-bit key for pg_advisory_xact_lock, derived from the order id.
+ *
+ * readInt32BE yields a signed 32-bit integer, which is exactly the width
+ * pg_advisory_xact_lock's single-argument form takes. The order id itself never
+ * reaches SQL — only this number does, and it is passed as a bind parameter.
+ *
+ * 32 bits means distinct orders can collide (~2 per 200k ids). A collision
+ * only serializes two unrelated orders against each other, which is slower
+ * but never incorrect, so the simpler single-argument lock form is worth it.
+ */
+function lockKeyFor(printfulOrderId) {
+    const digest = (0, crypto_1.createHash)("sha256").update(String(printfulOrderId)).digest();
+    return digest.readInt32BE(0);
+}
 /**
  * Detect a Postgres unique-constraint violation (SQLSTATE 23505) regardless of
  * how the ORM wraps the driver error. Used to turn a lost insert race into a
  * clean "already claimed" signal instead of a thrown error.
+ *
+ * The mapped-MedusaError branch is load-bearing and cannot be dropped. Medusa's
+ * dbErrorMapper (@medusajs/utils dal/mikro-orm/db-error-mapper) intercepts the
+ * driver's 23505 and throws a BRAND NEW MedusaError carrying only
+ * `type: "invalid_data"` and a prose message ending "already exists." — no
+ * `code`, no `cause` chain, and no "23505" anywhere in the text. Every other
+ * branch here misses it. Without this check a redelivered webhook (which
+ * Printful sends by design) surfaces as a 500 instead of being absorbed as a
+ * duplicate, and Printful then retries an event that can never succeed.
+ * Verified against a real Postgres in tests/webhook-route.integration.test.ts.
  */
 function isUniqueViolation(err) {
     if (!err || typeof err !== "object") {
@@ -29,6 +72,11 @@ function isUniqueViolation(err) {
     if (typeof e.message === "string" && e.message.includes("23505")) {
         return true;
     }
+    if (e.type === "invalid_data" &&
+        typeof e.message === "string" &&
+        /already exists\.?$/i.test(e.message.trim())) {
+        return true;
+    }
     if (e.cause && e.cause !== err) {
         return isUniqueViolation(e.cause);
     }
@@ -39,6 +87,7 @@ class PrintfulModuleService extends (0, utils_1.MedusaService)({
     PrintfulVariantLink: printful_variant_link_1.default,
     PrintfulSyncLog: printful_sync_log_1.default,
     PrintfulOrderLink: printful_order_link_1.default,
+    PrintfulWebhookEvent: printful_webhook_event_1.default,
 }) {
     constructor(container, options) {
         // MedusaService multi-arg constructor
@@ -92,6 +141,77 @@ class PrintfulModuleService extends (0, utils_1.MedusaService)({
         });
         return link ?? null;
     }
+    /** Reverse lookup used by webhooks, which only know the Printful order id. */
+    async findOrderLinkByPrintfulId(printfulOrderId) {
+        const [link] = await this.listPrintfulOrderLinks({
+            printful_order_id: String(printfulOrderId),
+        });
+        return link ?? null;
+    }
+    /**
+     * Store an inbound event. Returns null when the event_id already exists,
+     * which is how redelivered webhooks are absorbed.
+     */
+    async recordWebhookEvent(input) {
+        try {
+            return await this.createPrintfulWebhookEvents({
+                event_id: input.event_id,
+                type: input.type,
+                printful_order_id: input.printful_order_id,
+                printful_shipment_id: input.printful_shipment_id ?? null,
+                payload: input.payload,
+                status: input.status ?? "received",
+                attempts: 0,
+                next_retry_at: new Date(),
+            });
+        }
+        catch (err) {
+            if (isUniqueViolation(err)) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async findWebhookEvent(eventId) {
+        const [event] = await this.listPrintfulWebhookEvents({ event_id: eventId });
+        return event ?? null;
+    }
+    /**
+     * Events due for another processing attempt, most overdue first. Ordering by
+     * next_retry_at (not created_at) lets the ("status", "next_retry_at") index
+     * satisfy the sort instead of paying an explicit Sort node on every sweep.
+     */
+    async listDueWebhookEvents(limit = 50) {
+        return this.listPrintfulWebhookEvents({
+            status: ["received", "deferred"],
+            next_retry_at: { $lte: new Date() },
+            attempts: { $lt: exports.MAX_WEBHOOK_ATTEMPTS },
+        }, { take: limit, order: { next_retry_at: "ASC" } });
+    }
+    /**
+     * Serialize work per Printful order. Two events for one order must not be
+     * applied concurrently: both could pass the "shipment already recorded"
+     * check before either writes, producing two fulfillments for one parcel.
+     * Different orders remain parallel.
+     *
+     * This provides serialization, NOT atomicity. Work performed inside `fn`
+     * (core-flow runs, module-service writes) uses its own managers and commits
+     * independently of this transaction, so a later failure does not roll the
+     * earlier writes back. Callers must not assume all-or-nothing semantics.
+     *
+     * Uses the transaction-scoped lock deliberately. The session-scoped variant
+     * cannot work here: getActiveManager() forks without a transaction context,
+     * so knex takes a fresh pool connection per statement and the unlock can land
+     * on a different connection than the lock — leaking the lock permanently.
+     * pg_advisory_xact_lock is released by Postgres on commit or rollback.
+     */
+    async withOrderLock(printfulOrderId, fn) {
+        const key = lockKeyFor(printfulOrderId);
+        return this.baseRepository_.transaction(async (txManager) => {
+            await txManager.execute("select pg_advisory_xact_lock(?)", [key]);
+            return await fn();
+        });
+    }
     /**
      * Atomically claim an order for Printful creation. Relies on the unique index
      * on `medusa_order_id` so that concurrent captures cannot both proceed to
@@ -123,4 +243,4 @@ class PrintfulModuleService extends (0, utils_1.MedusaService)({
     }
 }
 exports.default = PrintfulModuleService;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9tb2R1bGVzL3ByaW50ZnVsL3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBa0JBLDhDQWVDO0FBakNELHFEQUF5RDtBQUN6RCxpRUFBNEQ7QUFFNUQsdUZBQTREO0FBQzVELDJGQUFnRTtBQUNoRSxtRkFBd0Q7QUFDeEQsMkZBQWdFO0FBSWhFLDhFQUE4RTtBQUNqRSxRQUFBLHlCQUF5QixHQUFHLFNBQVMsQ0FBQTtBQUVsRDs7OztHQUlHO0FBQ0gsU0FBZ0IsaUJBQWlCLENBQUMsR0FBWTtJQUM1QyxJQUFJLENBQUMsR0FBRyxJQUFJLE9BQU8sR0FBRyxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ3BDLE9BQU8sS0FBSyxDQUFBO0lBQ2QsQ0FBQztJQUNELE1BQU0sQ0FBQyxHQUFHLEdBQTJELENBQUE7SUFDckUsSUFBSSxDQUFDLENBQUMsSUFBSSxLQUFLLE9BQU8sRUFBRSxDQUFDO1FBQ3ZCLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUNELElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1FBQ2pFLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUNELElBQUksQ0FBQyxDQUFDLEtBQUssSUFBSSxDQUFDLENBQUMsS0FBSyxLQUFLLEdBQUcsRUFBRSxDQUFDO1FBQy9CLE9BQU8saUJBQWlCLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQ25DLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQTtBQUNkLENBQUM7QUFFRCxNQUFNLHFCQUFzQixTQUFRLElBQUEscUJBQWEsRUFBQztJQUNoRCxtQkFBbUIsRUFBbkIsK0JBQW1CO0lBQ25CLG1CQUFtQixFQUFuQiwrQkFBbUI7SUFDbkIsZUFBZSxFQUFmLDJCQUFlO0lBQ2YsaUJBQWlCLEVBQWpCLDZCQUFpQjtDQUNsQixDQUFDO0lBSUEsWUFBWSxTQUErQixFQUFFLE9BQStCO1FBQzFFLHNDQUFzQztRQUN0QyxLQUFLLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FBQTtRQUpYLFlBQU8sR0FBMEIsSUFBSSxDQUFBO1FBSzdDLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBTyxJQUFLLEVBQTRCLENBQUE7SUFDMUQsQ0FBQztJQUVELEtBQUssQ0FBQyxVQUFVO1FBQ2QsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFBO0lBQ3RCLENBQUM7SUFFRCxLQUFLLENBQUMsU0FBUztRQUNiLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbEIsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsUUFBUSxFQUFFLENBQUM7Z0JBQzdCLE1BQU0sSUFBSSxLQUFLLENBQ2IsOEVBQThFLENBQy9FLENBQUE7WUFDSCxDQUFDO1lBQ0QsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLGdDQUFjLENBQUM7Z0JBQ2hDLFFBQVEsRUFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVE7Z0JBQ2hDLE9BQU8sRUFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU87YUFDL0IsQ0FBQyxDQUFBO1FBQ0osQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUNyQixDQUFDO0lBRUQsS0FBSyxDQUFDLFVBQVU7UUFDZCxPQUFPLElBQUksQ0FBQyxRQUFRLEVBQUUsT0FBTyxJQUFJLFNBQVMsQ0FBQTtJQUM1QyxDQUFDO0lBRUQsS0FBSyxDQUFDLGVBQWUsQ0FBQyxhQUFxQjtRQUN6QyxNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQTtRQUN2QyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxJQUFJLENBQUMsd0JBQXdCLENBQUM7WUFDakQsaUJBQWlCLEVBQUUsT0FBTztZQUMxQix3QkFBd0IsRUFBRSxNQUFNLENBQUMsYUFBYSxDQUFDO1NBQ2hELENBQUMsQ0FBQTtRQUNGLE9BQU8sSUFBSSxJQUFJLElBQUksQ0FBQTtJQUNyQixDQUFDO0lBRUQsS0FBSyxDQUFDLGVBQWUsQ0FBQyxhQUFxQjtRQUN6QyxNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQTtRQUN2QyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxJQUFJLENBQUMsd0JBQXdCLENBQUM7WUFDakQsaUJBQWlCLEVBQUUsT0FBTztZQUMxQix3QkFBd0IsRUFBRSxNQUFNLENBQUMsYUFBYSxDQUFDO1NBQ2hELENBQUMsQ0FBQTtRQUNGLE9BQU8sSUFBSSxJQUFJLElBQUksQ0FBQTtJQUNyQixDQUFDO0lBRUQsS0FBSyxDQUFDLHlCQUF5QixDQUFDLGVBQXVCO1FBQ3JELE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLElBQUksQ0FBQyx3QkFBd0IsQ0FBQztZQUNqRCxpQkFBaUIsRUFBRSxlQUFlO1NBQ25DLENBQUMsQ0FBQTtRQUNGLE9BQU8sSUFBSSxJQUFJLElBQUksQ0FBQTtJQUNyQixDQUFDO0lBRUQsS0FBSyxDQUFDLGFBQWEsQ0FBQyxhQUFxQjtRQUN2QyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxJQUFJLENBQUMsc0JBQXNCLENBQUM7WUFDL0MsZUFBZSxFQUFFLGFBQWE7U0FDL0IsQ0FBQyxDQUFBO1FBQ0YsT0FBTyxJQUFJLElBQUksSUFBSSxDQUFBO0lBQ3JCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsS0FBSyxDQUFDLGNBQWMsQ0FBQyxhQUFxQjtRQUl4QyxJQUFJLENBQUM7WUFDSCxNQUFNLElBQUksR0FBRyxNQUFNLElBQUksQ0FBQyx3QkFBd0IsQ0FBQztnQkFDL0MsZUFBZSxFQUFFLGFBQWE7Z0JBQzlCLGlCQUFpQixFQUFFLGlDQUF5QjtnQkFDNUMsV0FBVyxFQUFFLGFBQWE7Z0JBQzFCLE1BQU0sRUFBRSxTQUFTO2FBQ2xCLENBQUMsQ0FBQTtZQUNGLE9BQU8sSUFBSSxDQUFBO1FBQ2IsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixJQUFJLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQzNCLE9BQU8sSUFBSSxDQUFBO1lBQ2IsQ0FBQztZQUNELE1BQU0sR0FBRyxDQUFBO1FBQ1gsQ0FBQztJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsZ0JBQWdCO1FBQ3BCLE1BQU0sSUFBSSxHQUFHLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixDQUMxQyxFQUFFLEVBQ0YsRUFBRSxJQUFJLEVBQUUsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUMzQyxDQUFBO1FBQ0QsT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFBO0lBQ3hCLENBQUM7Q0FDRjtBQUVELGtCQUFlLHFCQUFxQixDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/providers/printful-fulfillment/service.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/framework/utils");
 const printful_client_1 = require("../../utils/printful-client");
+const mappers_1 = require("../../utils/mappers");
+const shipping_rates_1 = require("../../utils/shipping-rates");
 class PrintfulFulfillmentProviderService extends utils_1.AbstractFulfillmentProviderService {
     constructor(container, options) {
         super();
@@ -10,6 +12,34 @@ class PrintfulFulfillmentProviderService extends utils_1.AbstractFulfillmentProv
         if (!this.options_.apiToken) {
             this.logger_.warn("Printful fulfillment provider: apiToken is missing from options");
         }
+        this.query_ = container.query;
+        this.cache_ = container.caching;
+        if (this.options_.liveShippingRates && !this.query_) {
+            this.logger_.error("Printful live shipping rates need variant metadata, which requires " +
+                'adding dependencies: ["query"] to the @medusajs/medusa/fulfillment ' +
+                "module in medusa-config.ts. Falling back to flat rates until then.");
+        }
+        if (this.options_.liveShippingRates &&
+            !this.options_.fallbackShippingRates) {
+            this.logger_.error("Printful live shipping rates are enabled without fallbackShippingRates. " +
+                "A Printful outage will price shipping at zero.");
+        }
+        // Coerce the TTLs once here rather than trusting them on every call: they
+        // arrive from user config and may be strings, zero, or absent.
+        const freshSeconds = Number(this.options_.shippingRateCacheTtlSeconds) > 0
+            ? Number(this.options_.shippingRateCacheTtlSeconds)
+            : 600;
+        const staleSeconds = Number(this.options_.shippingRateStaleSeconds) > 0
+            ? Number(this.options_.shippingRateStaleSeconds)
+            : 86400;
+        // The stale tier cannot outlive the cache entry, so retention must be at
+        // least the freshness window.
+        this.freshnessMs_ = freshSeconds * 1000;
+        this.staleSeconds_ = Math.max(freshSeconds, staleSeconds);
+        if (staleSeconds < freshSeconds) {
+            this.logger_.warn("shippingRateStaleSeconds is below shippingRateCacheTtlSeconds; " +
+                "raising it, since a stale quote cannot outlive its cache entry.");
+        }
         this.client_ = new printful_client_1.PrintfulClient({
             apiToken: this.options_.apiToken || "",
             storeId: this.options_.storeId,
@@ -17,32 +47,259 @@ class PrintfulFulfillmentProviderService extends utils_1.AbstractFulfillmentProv
     }
     async getFulfillmentOptions() {
         return [
+            ...shipping_rates_1.PRINTFUL_SHIPPING_METHODS.map((id) => ({
+                id,
+                name: `Printful ${id}`,
+            })),
             {
-                id: "printful-standard",
-                name: "Printful Standard",
-            },
-            {
-                id: "printful-return",
+                id: shipping_rates_1.PRINTFUL_RETURN_OPTION_ID,
                 name: "Printful Return",
                 is_return: true,
             },
         ];
     }
     async validateOption(data) {
-        return typeof data?.id === "string" || data?.id == null;
+        const id = data?.id;
+        return (typeof id === "string" &&
+            (shipping_rates_1.PRINTFUL_SHIPPING_METHODS.includes(id) ||
+                id === shipping_rates_1.PRINTFUL_RETURN_OPTION_ID));
     }
     async validateFulfillmentData(optionData, data, _context) {
-        return {
-            ...data,
-            printful_option_id: optionData?.id ?? "printful-standard",
+        // Runs when the method is added to the cart, not on every price refresh, so
+        // throwing here does not violate calculatePrice's never-throw constraint.
+        // Inventing a default would record one method on the order while the
+        // customer was priced for another.
+        const id = optionData?.id;
+        if (typeof id !== "string" ||
+            !shipping_rates_1.PRINTFUL_SHIPPING_METHODS.includes(id)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Printful shipping option has an unrecognized method id ` +
+                `(${JSON.stringify(id)}). Recreate it against one of: ` +
+                `${shipping_rates_1.PRINTFUL_SHIPPING_METHODS.join(", ")}.`);
+        }
+        return { ...data, printful_option_id: id };
+    }
+    async canCalculate(data) {
+        const optionId = data?.data?.id;
+        // Printful quotes outbound shipping only — a return has no live rate, so
+        // it must be priced flat by the admin rather than resolving to zero.
+        if (optionId === shipping_rates_1.PRINTFUL_RETURN_OPTION_ID) {
+            return false;
+        }
+        return Boolean(this.options_.liveShippingRates);
+    }
+    /**
+     * Price one shipping option.
+     *
+     * This method must never throw and must always return a `calculated_amount`.
+     * Medusa blocks checkout when it does not, so every failure — Printful down,
+     * method missing, currency unusable, config incomplete — resolves to a
+     * fallback rather than an exception.
+     */
+    async calculatePrice(optionData, _data, context) {
+        const methodId = String(optionData?.id ?? "");
+        try {
+            return await this.quote(methodId, context);
+        }
+        catch (err) {
+            // A bug in our own code must not block a cart either.
+            this.logger_.error(`Printful rate calculation failed unexpectedly: ${err instanceof Error ? err.message : String(err)}`);
+            return this.fallback(methodId, "printful_unreachable");
+        }
+    }
+    async quote(methodId, context) {
+        const ctx = context;
+        if (!this.query_) {
+            return this.fallback(methodId, "query_unavailable");
+        }
+        const addr = ctx.shipping_address ?? {};
+        const countryCode = (addr.country_code ?? "").toUpperCase();
+        const stateCode = (0, mappers_1.resolveStateCode)(addr.province, countryCode);
+        if (!(0, shipping_rates_1.isAddressQuotable)({ country_code: countryCode, state_code: stateCode })) {
+            return this.fallback(methodId, "incomplete_address");
+        }
+        const lines = (ctx.items ?? [])
+            .filter((i) => i.variant?.id)
+            .map((i) => ({
+            variant_id: i.variant.id,
+            quantity: Number(i.quantity ?? 1),
+            unit_price: i.unit_price,
+        }));
+        let catalogIds;
+        try {
+            catalogIds = await this.catalogIdsFor(lines.map((l) => l.variant_id));
+        }
+        catch (err) {
+            // Our own database, not Printful. Misreporting this sends the operator
+            // to Printful's status page during their own incident.
+            this.logger_.error(`Printful rate lookup: variant query failed: ${err instanceof Error ? err.message : String(err)}`);
+            return this.fallback(methodId, "query_unavailable");
+        }
+        const items = (0, shipping_rates_1.buildRateItems)(lines, catalogIds);
+        if (!items.length) {
+            return this.fallback(methodId, "no_printful_items");
+        }
+        const currency = (ctx.currency_code ?? "").toUpperCase();
+        const recipient = {
+            country_code: countryCode,
+            ...(stateCode ? { state_code: stateCode } : {}),
+            ...(addr.city ? { city: addr.city } : {}),
+            ...(addr.postal_code ? { zip: addr.postal_code } : {}),
+            ...(addr.address_1 ? { address1: addr.address_1 } : {}),
+            ...(addr.address_2 ? { address2: addr.address_2 } : {}),
         };
+        const cacheKey = (0, shipping_rates_1.buildRateCacheKey)({ address: recipient, items, currency });
+        const cached = await this.readCache(cacheKey);
+        // A negative age means the entry is dated in the future — clock skew on the
+        // cache node — which would otherwise read as fresh until that date passes.
+        const age = cached ? Date.now() - cached.cached_at : 0;
+        if (cached && age >= 0 && age < this.freshnessMs_) {
+            const hit = (0, shipping_rates_1.selectRate)(cached.rates, methodId, currency);
+            if (hit.ok) {
+                return this.priced(hit.amount, methodId, "fresh_cache");
+            }
+        }
+        let rates;
+        try {
+            rates = await this.client_.getShippingRates({
+                recipient,
+                items,
+                ...(currency ? { currency } : {}),
+            });
+        }
+        catch (err) {
+            this.logger_.warn(`Printful shipping rates unavailable: ${err instanceof Error ? err.message : String(err)}`);
+            return this.staleOrFlat(cached, methodId, currency, "printful_unreachable");
+        }
+        await this.writeCache(cacheKey, { rates, currency, cached_at: Date.now() }, this.staleSeconds_);
+        const selected = (0, shipping_rates_1.selectRate)(rates, methodId, currency);
+        if (!selected.ok) {
+            this.logger_.warn(`Printful rate for ${methodId} unusable (${selected.reason}); falling back`);
+            return this.staleOrFlat(cached, methodId, currency, selected.reason);
+        }
+        return this.priced(selected.amount, methodId, "live");
     }
-    async canCalculate(_data) {
-        // Live rates are Phase 2
-        return false;
+    /** Look up Printful catalog variant ids for a set of Medusa variant ids. */
+    async catalogIdsFor(variantIds) {
+        const map = new Map();
+        if (!this.query_ || !variantIds.length) {
+            return map;
+        }
+        const { data } = await this.query_.graph({
+            entity: "product_variant",
+            fields: ["id", "metadata"],
+            filters: { id: variantIds },
+        });
+        // `graph` is expected to return an array; a non-array result (schema drift,
+        // an error envelope) would otherwise throw on iteration.
+        const rows = Array.isArray(data)
+            ? data
+            : [];
+        for (const row of rows) {
+            const catalogId = row.metadata?.printful_catalog_variant_id;
+            if (catalogId != null && catalogId !== "") {
+                map.set(row.id, String(catalogId));
+            }
+        }
+        return map;
     }
-    async calculatePrice(_optionData, _data, _context) {
-        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Printful fulfillment does not support calculated prices yet");
+    async readCache(key) {
+        if (!this.cache_) {
+            return null;
+        }
+        try {
+            const value = await this.cache_.get(key);
+            // Treat a malformed entry as a miss. Schema drift from an older version
+            // or a partial write would otherwise throw inside the fresh-path check,
+            // blocking the live API for the whole stale window while Printful is up.
+            if (!value ||
+                !Array.isArray(value.rates) ||
+                typeof value.cached_at !== "number" ||
+                !Number.isFinite(value.cached_at)) {
+                return null;
+            }
+            return value;
+        }
+        catch {
+            // A cache failure must not fail the quote.
+            return null;
+        }
+    }
+    async writeCache(key, value, ttlSeconds) {
+        if (!this.cache_) {
+            return;
+        }
+        try {
+            // TTL is the STALE window, not the freshness window: an aged entry must
+            // survive so it can serve as a fallback.
+            await this.cache_.set(key, value, ttlSeconds);
+        }
+        catch {
+            // Non-fatal.
+        }
+    }
+    staleOrFlat(cached, methodId, currency, reason) {
+        if (cached) {
+            const stale = (0, shipping_rates_1.selectRate)(cached.rates, methodId, currency);
+            if (stale.ok) {
+                return this.priced(stale.amount, methodId, "stale_cache");
+            }
+        }
+        return this.fallback(methodId, reason);
+    }
+    fallback(methodId, reason) {
+        // Read as an own property: a method id like "toString" would otherwise
+        // resolve up the prototype chain to a function, which JSON.stringify drops
+        // from the response entirely — the exact missing-field condition that
+        // blocks checkout. Type-check it too, since a rate from JSON or an env var
+        // arrives as a string.
+        const table = this.options_.fallbackShippingRates;
+        const configured = Object.prototype.hasOwnProperty.call(table ?? {}, methodId)
+            ? table[methodId]
+            : undefined;
+        const flat = typeof configured === "number" &&
+            Number.isFinite(configured) &&
+            configured >= 0
+            ? configured
+            : undefined;
+        if (flat == null) {
+            // calculatePrice cannot throw, so a legacy option row silently prices at
+            // zero. Naming the id is the only mitigation available.
+            if (shipping_rates_1.LEGACY_OPTION_IDS.has(methodId)) {
+                this.logger_.error(`Shipping option uses the pre-0.3.0 id "${methodId}", which Printful ` +
+                    `never returns, so it is pricing at zero. Recreate this option ` +
+                    `against one of: ${shipping_rates_1.PRINTFUL_SHIPPING_METHODS.join(", ")}.`);
+            }
+            else {
+                this.logger_.error(`No usable fallbackShippingRates entry for "${methodId}" — pricing ` +
+                    "shipping at zero. Every method in the allowlist needs a " +
+                    "non-negative numeric entry.");
+            }
+            return this.priced(0, methodId, "misconfigured_zero");
+        }
+        if (reason === "incomplete_address" || reason === "no_printful_items") {
+            this.logger_.debug?.(`Printful rates skipped: ${reason}`);
+        }
+        else if (reason === "query_unavailable") {
+            // Only advise the config change when query really is absent; a query that
+            // exists but failed has already logged its own, accurate reason.
+            if (!this.query_) {
+                this.logger_.error('Printful live rates need dependencies: ["query"] on the fulfillment module');
+            }
+        }
+        else {
+            this.logger_.warn(`Printful rate fallback (${reason}) for ${methodId}`);
+        }
+        return this.priced(flat, methodId, "flat_fallback");
+    }
+    priced(amount, _methodId, _source) {
+        // The source is deliberately not returned. Medusa reads only
+        // calculated_amount and is_calculated_price_tax_inclusive off this result
+        // (core-flows add-shipping-method-to-cart.js) — a `data` field here is
+        // discarded, so stamping provenance on it would be silently dead code.
+        return {
+            calculated_amount: amount,
+            is_calculated_price_tax_inclusive: false,
+        };
     }
     async createFulfillment(data, items, order, fulfillment) {
         // Prefer order created by payment.captured subscriber; attach id if present.
@@ -94,4 +351,4 @@ class PrintfulFulfillmentProviderService extends utils_1.AbstractFulfillmentProv
 }
 PrintfulFulfillmentProviderService.identifier = "printful";
 exports.default = PrintfulFulfillmentProviderService;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvcHJpbnRmdWwtZnVsZmlsbG1lbnQvc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHFEQUdrQztBQVdsQyxpRUFBNEQ7QUFXNUQsTUFBTSxrQ0FBbUMsU0FBUSwwQ0FBa0M7SUFPakYsWUFBWSxTQUErQixFQUFFLE9BQThCO1FBQ3pFLEtBQUssRUFBRSxDQUFBO1FBQ1AsSUFBSSxDQUFDLE9BQU8sR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFBO1FBQy9CLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBTyxJQUFLLEVBQTRCLENBQUE7UUFFeEQsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDNUIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQ2YsaUVBQWlFLENBQ2xFLENBQUE7UUFDSCxDQUFDO1FBRUQsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLGdDQUFjLENBQUM7WUFDaEMsUUFBUSxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxJQUFJLEVBQUU7WUFDdEMsT0FBTyxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTztTQUMvQixDQUFDLENBQUE7SUFDSixDQUFDO0lBRUQsS0FBSyxDQUFDLHFCQUFxQjtRQUN6QixPQUFPO1lBQ0w7Z0JBQ0UsRUFBRSxFQUFFLG1CQUFtQjtnQkFDdkIsSUFBSSxFQUFFLG1CQUFtQjthQUMxQjtZQUNEO2dCQUNFLEVBQUUsRUFBRSxpQkFBaUI7Z0JBQ3JCLElBQUksRUFBRSxpQkFBaUI7Z0JBQ3ZCLFNBQVMsRUFBRSxJQUFJO2FBQ2hCO1NBQ0YsQ0FBQTtJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsY0FBYyxDQUFDLElBQTZCO1FBQ2hELE9BQU8sT0FBTyxJQUFJLEVBQUUsRUFBRSxLQUFLLFFBQVEsSUFBSSxJQUFJLEVBQUUsRUFBRSxJQUFJLElBQUksQ0FBQTtJQUN6RCxDQUFDO0lBRUQsS0FBSyxDQUFDLHVCQUF1QixDQUMzQixVQUFtQyxFQUNuQyxJQUE2QixFQUM3QixRQUFpQztRQUVqQyxPQUFPO1lBQ0wsR0FBRyxJQUFJO1lBQ1Asa0JBQWtCLEVBQUUsVUFBVSxFQUFFLEVBQUUsSUFBSSxtQkFBbUI7U0FDMUQsQ0FBQTtJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsWUFBWSxDQUFDLEtBQThCO1FBQy9DLHlCQUF5QjtRQUN6QixPQUFPLEtBQUssQ0FBQTtJQUNkLENBQUM7SUFFRCxLQUFLLENBQUMsY0FBYyxDQUNsQixXQUEwRCxFQUMxRCxLQUE4QyxFQUM5QyxRQUFvRDtRQUVwRCxNQUFNLElBQUksbUJBQVcsQ0FDbkIsbUJBQVcsQ0FBQyxLQUFLLENBQUMsV0FBVyxFQUM3Qiw2REFBNkQsQ0FDOUQsQ0FBQTtJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsaUJBQWlCLENBQ3JCLElBQTZCLEVBQzdCLEtBQXlELEVBQ3pELEtBQStDLEVBQy9DLFdBRUM7UUFFRCw2RUFBNkU7UUFDN0UsTUFBTSxVQUFVLEdBQ2IsSUFBSSxFQUFFLGlCQUF3QztZQUM5QyxXQUFXLEVBQUUsUUFBUSxFQUFFLGlCQUF3QyxDQUFBO1FBRWxFLElBQUksVUFBVSxFQUFFLENBQUM7WUFDZixPQUFPO2dCQUNMLElBQUksRUFBRTtvQkFDSixHQUFHLENBQUMsT0FBTyxJQUFJLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztvQkFDekMsaUJBQWlCLEVBQUUsVUFBVTtpQkFDOUI7Z0JBQ0QsTUFBTSxFQUFFLEVBQUU7YUFDWCxDQUFBO1FBQ0gsQ0FBQztRQUVELDJFQUEyRTtRQUMzRSw4RUFBOEU7UUFDOUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQ2YsMENBQTBDLEtBQUssRUFBRSxFQUFFLElBQUksU0FBUyxHQUFHO1lBQ2pFLFdBQVcsS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDLDREQUE0RCxDQUM1RixDQUFBO1FBRUQsT0FBTztZQUNMLElBQUksRUFBRTtnQkFDSixHQUFHLENBQUMsT0FBTyxJQUFJLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztnQkFDekMsZUFBZSxFQUFFLEtBQUssRUFBRSxFQUFFO2FBQzNCO1lBQ0QsTUFBTSxFQUFFLEVBQUU7U0FDWCxDQUFBO0lBQ0gsQ0FBQztJQUVELEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxJQUE2QjtRQUNuRCxNQUFNLGVBQWUsR0FBRyxJQUFJLEVBQUUsaUJBQXVDLENBQUE7UUFDckUsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1lBQ3JCLE9BQU8sRUFBRSxDQUFBO1FBQ1gsQ0FBQztRQUVELElBQUksQ0FBQztZQUNILE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUFDLENBQUE7UUFDakQsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FDaEIsbUNBQW1DLGVBQWUsS0FDaEQsR0FBRyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FDakQsRUFBRSxDQUNILENBQUE7UUFDSCxDQUFDO1FBRUQsT0FBTyxFQUFFLENBQUE7SUFDWCxDQUFDO0lBRUQsS0FBSyxDQUFDLHVCQUF1QixDQUMzQixXQUFvQztRQUVwQyxPQUFPO1lBQ0wsSUFBSSxFQUFFO2dCQUNKLEdBQUksV0FBVyxFQUFFLElBQWU7Z0JBQ2hDLFNBQVMsRUFBRSxJQUFJO2FBQ2hCO1lBQ0QsTUFBTSxFQUFFLEVBQUU7U0FDWCxDQUFBO0lBQ0gsQ0FBQzs7QUF4SU0sNkNBQVUsR0FBRyxVQUFVLENBQUE7QUEySWhDLGtCQUFlLGtDQUFrQyxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/providers/printful-fulfillment/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/subscribers/payment-captured.js

@@ -58,4 +58,4 @@ async function resolveOrderIdFromPayment(container, paymentId) {
 exports.config = {
     event: "payment.captured",
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bWVudC1jYXB0dXJlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zdWJzY3JpYmVycy9wYXltZW50LWNhcHR1cmVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQVVBLHlDQWlDQztBQXpDRCxxREFBOEU7QUFDOUUsK0ZBQTRFO0FBRTVFOzs7O0dBSUc7QUFDWSxLQUFLLFVBQVUsc0JBQXNCLENBQUMsRUFDbkQsS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFLEVBQ2YsU0FBUyxHQUNzQjtJQUMvQixNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFBO0lBQ3pCLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUNmLE9BQU07SUFDUixDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQUcsU0FBUyxDQUFDLE9BQU8sQ0FBQyxpQ0FBeUIsQ0FBQyxNQUFNLENBR2hFLENBQUE7SUFFRCxJQUFJLENBQUM7UUFDSCxNQUFNLE9BQU8sR0FBRyxNQUFNLHlCQUF5QixDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUMsQ0FBQTtRQUNyRSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDYixNQUFNLENBQUMsS0FBSyxDQUNWLGlEQUFpRCxTQUFTLEVBQUUsQ0FDN0QsQ0FBQTtZQUNELE9BQU07UUFDUixDQUFDO1FBRUQsTUFBTSxJQUFBLCtCQUEyQixFQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztZQUMvQyxLQUFLLEVBQUUsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFO1NBQzdCLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1FBQ2IsTUFBTSxDQUFDLEtBQUssQ0FDVixnREFBZ0QsU0FBUyxLQUN2RCxHQUFHLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUNqRCxFQUFFLENBQ0gsQ0FBQTtJQUNILENBQUM7QUFDSCxDQUFDO0FBRUQsS0FBSyxVQUFVLHlCQUF5QixDQUN0QyxTQUEwQixFQUMxQixTQUFpQjtJQUVqQixNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLGVBQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQTtJQUN4RCxNQUFNLE9BQU8sR0FBRyxNQUFNLGFBQWEsQ0FBQyxlQUFlLENBQUMsU0FBUyxDQUFDLENBQUE7SUFDOUQsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLHFCQUEyQyxDQUFBO0lBQ3hFLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUNsQixPQUFPLElBQUksQ0FBQTtJQUNiLENBQUM7SUFFRCxNQUFNLEtBQUssR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLGlDQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQ2hFLE1BQU0sRUFBRSxJQUFJLEVBQUUsR0FBRyxNQUFNLEtBQUssQ0FBQyxLQUFLLENBQUM7UUFDakMsTUFBTSxFQUFFLDBCQUEwQjtRQUNsQyxNQUFNLEVBQUUsQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDO1FBQ2hDLE9BQU8sRUFBRTtZQUNQLHFCQUFxQixFQUFFLFlBQVk7U0FDcEM7S0FDRixDQUFDLENBQUE7SUFFRixNQUFNLEdBQUcsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQTtJQUNoRCxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDVCxPQUFPLElBQUksQ0FBQTtJQUNiLENBQUM7SUFFRCxPQUFPLENBQ0osR0FBc0QsQ0FBQyxRQUFRO1FBQy9ELEdBQW1DLENBQUMsS0FBSyxFQUFFLEVBQUU7UUFDOUMsSUFBSSxDQUNMLENBQUE7QUFDSCxDQUFDO0FBRVksUUFBQSxNQUFNLEdBQXFCO0lBQ3RDLEtBQUssRUFBRSxrQkFBa0I7Q0FDMUIsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,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