@legenki/print2medusa 0.8.1 → 0.9.2

package/.medusa/server/src/utils/clear-sync.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLEARED_BY_OPERATOR = exports.CLEAR_SYNC_CONFIRMATION = void 0;
+exports.planSyncClear = planSyncClear;
+/**
+ * Exact phrase the caller must send to clear a stuck sync.
+ *
+ * Clearing is destructive, so it must not be reachable by an empty POST. A
+ * typed phrase makes the operator's intent explicit and unambiguous in the
+ * request itself — a boolean `force: true` is too easy to send by accident
+ * from a curl line or a mis-wired button.
+ */
+exports.CLEAR_SYNC_CONFIRMATION = "clear-stuck-sync";
+/**
+ * Audit marker written to `error_message` when a human clears a sync.
+ *
+ * `reapStaleSyncLogs` writes the bare string "stale_running" when the timeout
+ * reclaims a row on its own. These two must never be confused: one says the
+ * system recovered by itself after `syncStaleMinutes`, the other says a person
+ * decided the sync was dead and intervened. Anyone reading this log six months
+ * from now needs to be able to tell those apart.
+ */
+exports.CLEARED_BY_OPERATOR = "cleared_by_operator";
+function toDate(value) {
+    if (value == null) {
+        return null;
+    }
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+/**
+ * Decide whether a running sync may be cleared by hand, and what to record.
+ *
+ * This exists instead of simply exposing `reapStaleSyncLogs(0)`, which would
+ * clear ANY running sync unconditionally. That call has no notion of whether
+ * the sync is alive: a healthy run mid-catalog would be marked `failed` while
+ * its process keeps writing, which both corrupts the log and frees the claim
+ * so a second sync can start against the same catalog.
+ *
+ * Two guards, deliberately layered:
+ *
+ *  1. The caller must send the confirmation phrase. Checked FIRST, so an
+ *     unconfirmed request against a live sync is told it is unconfirmed rather
+ *     than being told it is alive — the latter would wrongly imply that
+ *     confirming alone would have been enough.
+ *  2. The heartbeat must actually be stale. Confirmation proves intent, not
+ *     that the operator is right. An operator staring at a widget cannot see
+ *     the heartbeat; the server can, and refuses on their behalf.
+ *
+ * The stale window is clamped to a minimum of one minute so that passing 0 —
+ * the exact foot-gun this function replaces — cannot make a live sync
+ * clearable.
+ *
+ * A row with no heartbeat at all falls back to `started_at`. A crash between
+ * the claim insert and the first heartbeat leaves `heartbeat_at` null, and
+ * such a row must not be permanently unclearable; but a claim made seconds ago
+ * is far more likely to be a sync starting up than a dead one.
+ */
+function planSyncClear(input) {
+    const { log, confirmation, staleMinutes } = input;
+    const now = input.now ?? new Date();
+    if (!log || log.status !== "running") {
+        return { allowed: false, reason: "nothing_running" };
+    }
+    if (confirmation !== exports.CLEAR_SYNC_CONFIRMATION) {
+        return { allowed: false, reason: "unconfirmed", sync_id: log.id };
+    }
+    // Never trust a zero or negative window: that is precisely the call this
+    // function exists to prevent.
+    const window = Math.max(1, Number.isFinite(staleMinutes) ? staleMinutes : 1);
+    const lastSign = toDate(log.heartbeat_at) ?? toDate(log.started_at);
+    const silentMs = lastSign ? now.getTime() - lastSign.getTime() : Infinity;
+    const silentMinutes = Number.isFinite(silentMs)
+        ? Math.max(0, Math.floor(silentMs / 60_000))
+        : Number.MAX_SAFE_INTEGER;
+    if (silentMinutes < window) {
+        return {
+            allowed: false,
+            reason: "alive",
+            sync_id: log.id,
+            silent_minutes: silentMinutes,
+        };
+    }
+    return {
+        allowed: true,
+        sync_id: log.id,
+        error_message: `${exports.CLEARED_BY_OPERATOR}: no heartbeat for ${silentMinutes}m`,
+        silent_minutes: silentMinutes,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogVariantCache = exports.DESIGN_METADATA_KEY = exports.PLACEMENTS_BY_CLASS = void 0;
+exports.classifyProduct = classifyProduct;
+exports.placementsFor = placementsFor;
+exports.corePlacementsFor = corePlacementsFor;
+exports.planDesignParameters = planDesignParameters;
+exports.designProbeKey = designProbeKey;
+exports.enrichVariantsWithDesign = enrichVariantsWithDesign;
+exports.summarizeProductDesign = summarizeProductDesign;
+/**
+ * The placements a design actually uses, per class. A tee exposes 17; these
+ * are the ones the admin should lead with.
+ *
+ * `embroidery_front` is why this is a table and not a front/back filter: the
+ * cap has no `front` placement at all, so filtering on front/back returns an
+ * empty list for a product that plainly has somewhere to put a design.
+ */
+exports.PLACEMENTS_BY_CLASS = {
+    apparel: ["front", "back"],
+    embroidery: ["embroidery_front"],
+    print_media: ["default"],
+};
+/**
+ * Placement ids that are not print areas. Printful returns mockup and preview
+ * entries in the same `files` list as real placements.
+ */
+const NON_PLACEMENT_TYPES = new Set(["preview", "mockup", "template"]);
+/** Printful technique keys, normalized to the names a human uses. */
+const TECHNIQUE_NAMES = {
+    dtg: "DTG",
+    dtfilm: "DTF",
+    dtf: "DTF",
+    embroidery: "EMBROIDERY",
+    digital: "DIGITAL",
+    cut_sew: "CUT_SEW",
+    sublimation: "SUBLIMATION",
+    uv: "UV",
+};
+/**
+ * Techniques that mean the design is *printed* onto fabric.
+ *
+ * DTF is deliberately absent. The cap supports EMBROIDERY and DTF and no DTG,
+ * and DTF alone is an accessory transfer Printful offers almost everywhere —
+ * treating it as evidence of apparel is exactly what turns the cap into a
+ * garment with front/back placements it does not have. DTG (or sublimation) is
+ * the technique that says "this is a printable garment".
+ */
+const PRINTED_ON_FABRIC = new Set(["dtg", "sublimation"]);
+/** Film transfer. Supported broadly; never on its own evidence of a class. */
+const FILM = new Set(["dtfilm", "dtf"]);
+function techniqueKeys(variant) {
+    const keys = [];
+    for (const t of variant.product?.techniques ?? []) {
+        const key = t?.key?.trim().toLowerCase();
+        if (key) {
+            keys.push(key);
+        }
+    }
+    return keys;
+}
+function normalizeTechnique(key) {
+    return TECHNIQUE_NAMES[key] ?? key.toUpperCase();
+}
+/**
+ * Decide the product class from what Printful says the variant supports.
+ *
+ * Order matters. `print_media` is checked before the fabric classes because
+ * DIGITAL is the only technique a poster or sticker reports, and a store that
+ * later stocks a DIGITAL-plus-DTG product is a garment, not paper.
+ *
+ * A variant with no techniques returns `unknown` rather than defaulting to
+ * apparel. Guessing here would put front/back placements on something that may
+ * have neither, and an admin reading a confident wrong answer is worse off
+ * than one reading no answer.
+ */
+function classifyProduct(variant) {
+    if (!variant) {
+        return "unknown";
+    }
+    const keys = techniqueKeys(variant);
+    if (keys.length === 0) {
+        return "unknown";
+    }
+    const set = new Set(keys);
+    const hasPrintOnFabric = keys.some((k) => PRINTED_ON_FABRIC.has(k));
+    const hasFilm = keys.some((k) => FILM.has(k));
+    const hasEmbroidery = set.has("embroidery");
+    // Paper and vinyl: DIGITAL and nothing that touches fabric.
+    if (set.has("digital") && !hasPrintOnFabric && !hasFilm && !hasEmbroidery) {
+        return "print_media";
+    }
+    // Ink on fabric wins over thread: a tee supports embroidery too, but its
+    // design goes on with DTG.
+    if (hasPrintOnFabric) {
+        return "apparel";
+    }
+    // Thread, with no DTG anywhere. The cap. DTF may sit alongside it and does
+    // not make this apparel — the placement is `embroidery_front`, not `front`.
+    if (hasEmbroidery) {
+        return "embroidery";
+    }
+    // Film and nothing else: still a print on fabric, just not a direct one.
+    if (hasFilm) {
+        return "apparel";
+    }
+    return "unknown";
+}
+/** Every real print placement the variant offers, mockups excluded. */
+function placementsFor(variant) {
+    const seen = new Set();
+    const out = [];
+    for (const f of variant?.product?.files ?? []) {
+        // `type`, not `id`. Printful names the primary placement `id: "default"`
+        // on every product and puts the meaning in `type` — a tee's default is
+        // `front`, a cap's is `embroidery_front`. Reading `id` therefore collapses
+        // every product's main placement to the same meaningless "default", which
+        // matched nothing in the core lists and left the cap with no placement at
+        // all. Verified against the live catalog for variants 4025 and 7853.
+        const id = (f?.type ?? f?.id)?.trim();
+        if (!id || NON_PLACEMENT_TYPES.has(id.toLowerCase()) || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+/**
+ * The placements a design actually uses on this variant: the class's core
+ * list, intersected with what the variant really offers.
+ *
+ * The intersection is what keeps this honest in both directions. It never
+ * invents a `back` on a front-only garment, and — because the table is keyed
+ * by class rather than hardcoded to front/back — it never returns an empty
+ * list for the cap, whose only placement is `embroidery_front`.
+ */
+function corePlacementsFor(variant) {
+    const productClass = classifyProduct(variant);
+    if (productClass === "unknown") {
+        return [];
+    }
+    const available = new Set(placementsFor(variant));
+    return exports.PLACEMENTS_BY_CLASS[productClass].filter((p) => available.has(p));
+}
+/**
+ * A hex colour, or nothing.
+ *
+ * Never returns `""`. An empty string renders as a black swatch, which tells
+ * the admin the shirt is black when in truth Printful did not say. Absence has
+ * to stay distinguishable from black.
+ */
+function normalizeHex(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return undefined;
+    }
+    const body = value.startsWith("#") ? value.slice(1) : value;
+    if (!/^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$/.test(body)) {
+        return undefined;
+    }
+    return `#${body.toLowerCase()}`;
+}
+/** "100% Airlume cotton", "50% cotton, 50% polyester", or nothing. */
+function summarizeMaterial(material) {
+    const parts = [];
+    for (const m of material ?? []) {
+        const name = m?.name?.trim();
+        if (!name) {
+            continue;
+        }
+        parts.push(m.percentage != null ? `${m.percentage}% ${name}` : name);
+    }
+    return parts.length ? parts.join(", ") : undefined;
+}
+/**
+ * The physical size of a print medium, when Printful states one.
+ *
+ * `dimensions` is keyed by size on posters and by placement on stickers, so
+ * the variant's own size is tried as a key first and a single-entry map falls
+ * through to its only value.
+ */
+function physicalDimensions(variant) {
+    const dims = variant.product?.dimensions;
+    if (!dims) {
+        return undefined;
+    }
+    const size = variant.variant?.size?.trim();
+    if (size && dims[size]) {
+        return dims[size];
+    }
+    const values = Object.values(dims).filter((v) => typeof v === "string" && v);
+    return values.length === 1 ? values[0] : values[0] || undefined;
+}
+function orderedTechniques(variant) {
+    const list = variant.product?.techniques ?? [];
+    const named = [];
+    let defaultName;
+    for (const t of list) {
+        const key = t?.key?.trim().toLowerCase();
+        if (!key) {
+            continue;
+        }
+        const name = normalizeTechnique(key);
+        if (!named.includes(name)) {
+            named.push(name);
+        }
+        if (t.is_default && !defaultName) {
+            defaultName = name;
+        }
+    }
+    // No explicit default: the first technique listed is the one Printful leads
+    // with, and it is a better answer than none.
+    return { technique: defaultName ?? named[0], techniques: named };
+}
+/**
+ * Build the design parameters for a catalog variant.
+ *
+ * Returns `null` when the variant cannot be classified. The caller is a
+ * best-effort sync enrichment: writing a half-guessed object into variant
+ * metadata would put an unfounded claim in front of the admin and into a
+ * later prompt, where nothing distinguishes it from a verified one.
+ */
+function planDesignParameters(variant) {
+    if (!variant) {
+        return null;
+    }
+    const productClass = classifyProduct(variant);
+    if (productClass === "unknown") {
+        return null;
+    }
+    const { technique, techniques } = orderedTechniques(variant);
+    const isPrintMedia = productClass === "print_media";
+    // Print media reports the stock's own colour — a poster is "White #ffffff".
+    // That is the paper, not a design parameter, and showing it as a swatch
+    // reads as a choice someone made.
+    const color = isPrintMedia ? undefined : variant.variant?.color?.trim();
+    const colorHex = isPrintMedia
+        ? undefined
+        : normalizeHex(variant.variant?.color_code);
+    return {
+        productClass,
+        ...(technique ? { technique } : {}),
+        techniques,
+        corePlacements: corePlacementsFor(variant),
+        placements: placementsFor(variant),
+        ...(color ? { color } : {}),
+        ...(colorHex ? { colorHex } : {}),
+        ...(variant.variant?.size?.trim()
+            ? { size: variant.variant.size.trim() }
+            : {}),
+        ...(summarizeMaterial(variant.variant?.material)
+            ? { material: summarizeMaterial(variant.variant?.material) }
+            : {}),
+        ...(variant.product?.brand?.trim()
+            ? { brand: variant.product.brand.trim() }
+            : {}),
+        ...(variant.product?.model?.trim()
+            ? { model: variant.product.model.trim() }
+            : {}),
+        ...(isPrintMedia && physicalDimensions(variant)
+            ? { dimensions: physicalDimensions(variant) }
+            : {}),
+        ...(variant.product?.id != null
+            ? { catalogProductId: String(variant.product.id) }
+            : {}),
+    };
+}
+/**
+ * Where design parameters live in variant metadata.
+ *
+ * Nested under one key rather than spread as `printful_design_color`,
+ * `printful_design_color_hex`, … The existing flat keys — `printful_store_id`,
+ * `printful_availability_status` — are each a single scalar the plugin reads
+ * back individually. This is one cohesive record read as a whole by one admin
+ * panel, and a dozen sibling keys would triple the width of every variant's
+ * metadata for no lookup that wants them separately. The `printful_design_`
+ * prefix is kept on the container so the namespace still reads at a glance.
+ */
+exports.DESIGN_METADATA_KEY = "printful_design";
+/**
+ * The identity of one catalog probe.
+ *
+ * This is the whole stampede defence, so it is a named function with its own
+ * tests rather than an inline template string.
+ *
+ * A tee is 84 colours across 9 sizes — 756 sync variants, each with its own
+ * catalog variant id. Asking the catalog about every one is 756 HTTP calls for
+ * a product whose technique, placements, brand and model are identical across
+ * all of them, and whose hex is identical across the sizes of a colour. So the
+ * probe is keyed by product and colour: 84 calls, not 756. Size is deliberately
+ * not part of the key — it is the axis that varies without changing any answer
+ * the catalog gives us, and it already arrives free on the sync variant.
+ */
+function designProbeKey(input) {
+    const color = input.color?.trim().toLowerCase() ?? "";
+    return `${input.syncProductId}::${color}`;
+}
+/**
+ * Memoizes catalog lookups by probe key for the life of one sync.
+ *
+ * Caches the *promise*, not the result, so two variants of the same colour
+ * reaching this concurrently share one in-flight request instead of racing to
+ * start two. Caches `null` answers too — a blank the catalog fails on must
+ * cost one call, not one per variant that shares it.
+ */
+class CatalogVariantCache {
+    constructor(fetchVariant) {
+        this.fetchVariant = fetchVariant;
+        this.entries = new Map();
+        this.made = 0;
+    }
+    /** How many catalog calls were actually issued. For logging and tests. */
+    get calls() {
+        return this.made;
+    }
+    async get(key, catalogVariantId) {
+        const cached = this.entries.get(key);
+        if (cached) {
+            return cached;
+        }
+        this.made += 1;
+        // Never let a rejection escape: this is a best-effort enrichment and the
+        // sync must survive a catalog that throws rather than returns null.
+        const pending = this.fetchVariant(String(catalogVariantId)).catch(() => null);
+        this.entries.set(key, pending);
+        return pending;
+    }
+}
+exports.CatalogVariantCache = CatalogVariantCache;
+/**
+ * Attach design parameters to already-mapped Medusa variants.
+ *
+ * Best-effort throughout. A `null` from the catalog, a variant with no catalog
+ * id, or a variant the classifier cannot place all leave the variant exactly as
+ * it arrived — importable, with its price, title and every other metadata key
+ * untouched. The key is omitted entirely rather than written as `null`, so
+ * "we never asked" and "we asked and learned nothing" do not render alike.
+ *
+ * `variants` and `syncVariants` are positionally paired, which is how the
+ * mapper produces them.
+ */
+async function enrichVariantsWithDesign(variants, syncVariants, options) {
+    const cache = options.cache ?? new CatalogVariantCache(options.getCatalogVariant);
+    return Promise.all(variants.map(async (variant, i) => {
+        const sync = syncVariants[i];
+        const catalogVariantId = sync?.variant_id;
+        // Nothing to look up. Printful leaves `variant_id` unset on sync
+        // variants it never bound to a catalog blank.
+        if (catalogVariantId == null || catalogVariantId === 0) {
+            return variant;
+        }
+        const key = designProbeKey({
+            syncProductId: options.syncProductId,
+            color: sync?.color,
+        });
+        const catalog = await cache.get(key, catalogVariantId);
+        if (!catalog) {
+            return variant;
+        }
+        const plan = planDesignParameters(catalog);
+        if (!plan) {
+            return variant;
+        }
+        // The probe answered for one arbitrary size of this colour, so its size
+        // is not this variant's. Everything else on the answer — technique,
+        // placements, hex, material, brand — is genuinely shared.
+        const size = sync?.size?.trim() || plan.size;
+        const design = {
+            ...plan,
+            ...(size ? { size } : {}),
+        };
+        if (!size) {
+            delete design.size;
+        }
+        return {
+            ...variant,
+            metadata: {
+                ...variant.metadata,
+                [exports.DESIGN_METADATA_KEY]: design,
+            },
+        };
+    }));
+}
+/**
+ * Fold a product's variants into one design summary.
+ *
+ * Product-level facts — class, technique, placements, brand — are identical
+ * across every variant, so the first variant carrying design metadata answers
+ * for the product. Colour and size are the axes that vary, and are collected.
+ *
+ * Returns `null` when no variant carries design metadata. That is deliberately
+ * distinct from a summary with empty fields: a product that was never enriched
+ * is not a product with no design parameters, and a page that renders the two
+ * identically tells the owner something false about a product that is fine.
+ */
+function summarizeProductDesign(variants) {
+    let shape;
+    const colors = [];
+    const sizes = [];
+    const seenColor = new Set();
+    const seenSize = new Set();
+    for (const variant of variants) {
+        const design = (variant?.metadata ?? {})[exports.DESIGN_METADATA_KEY];
+        if (!design) {
+            continue;
+        }
+        shape ??= design;
+        if (design.color && !seenColor.has(design.color)) {
+            seenColor.add(design.color);
+            // The hex rides with the name rather than being looked up separately:
+            // a swatch without one must render as absent, not as black.
+            colors.push({ name: design.color, hex: design.colorHex });
+        }
+        if (design.size && !seenSize.has(design.size)) {
+            seenSize.add(design.size);
+            sizes.push(design.size);
+        }
+    }
+    if (!shape) {
+        return null;
+    }
+    return {
+        product_class: shape.productClass,
+        technique: shape.technique,
+        techniques: shape.techniques,
+        core_placements: shape.corePlacements,
+        placements: shape.placements,
+        brand: shape.brand,
+        model: shape.model,
+        material: shape.material,
+        dimensions: shape.dimensions,
+        catalog_product_id: shape.catalogProductId,
+        colors,
+        sizes,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"design.js","sourceRoot":"","sources":["../../../../src/utils/design.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/utils/printful-client.js

@@ -107,6 +107,50 @@ class PrintfulClient {
         });
         return data.result ?? { url: null, types: [] };
     }
+    /**
+     * Catalog detail for one variant: colour and its hex, material, brand, and
+     * the techniques and placements the design can use.
+     *
+     * Reads `/products/variant/{id}` rather than `/products/{id}` because the
+     * techniques it lists are the ones applicable to **this variant**. Variant
+     * 4025 reports `DTG` alone where product 71 reports `DTG, EMBROIDERY,
+     * DTFILM` — the narrower answer is the true one for a given colour and size.
+     *
+     * Returns `null` on any failure rather than throwing. This is called during
+     * a catalog sync, and design parameters are an enrichment: losing them must
+     * not fail an import of a product that is otherwise fine to sell.
+     */
+    async getCatalogVariant(catalogVariantId) {
+        try {
+            const data = await this.request(`/products/variant/${catalogVariantId}`);
+            return data.result ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Sales, costs and profit for a date range.
+     *
+     * Returns the per-store list, empty when Printful reports none — the admin
+     * page maps over this, and a missing key must not crash the one screen whose
+     * job is telling the owner what is going on.
+     *
+     * `currency` is omitted rather than defaulted when absent: Printful then
+     * reports in the store's own currency, which is a different request from
+     * asking for a specific one.
+     */
+    async getStatistics(params) {
+        const search = new URLSearchParams();
+        search.set("date_from", params.dateFrom);
+        search.set("date_to", params.dateTo);
+        search.set("report_types", params.reportTypes);
+        if (params.currency) {
+            search.set("currency", params.currency);
+        }
+        const data = await this.request(`/reports/statistics?${search.toString()}`);
+        return data.result?.store_statistics ?? [];
+    }
     /**
      * Quote shipping for a cart. Returns every method Printful offers for that
      * destination in one response — the caller picks the one it needs.
@@ -208,4 +252,4 @@ class PrintfulClient {
     }
 }
 exports.PrintfulClient = PrintfulClient;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"printful-client.js","sourceRoot":"","sources":["../../../../src/utils/printful-client.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"printful-client.js","sourceRoot":"","sources":["../../../../src/utils/printful-client.ts"],"names":[],"mappings":"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"}