@hszrdm/core 1.3.0 → 1.5.0

package/.medusa/server/src/core/storefront-core-config.js

@@ -15,6 +15,19 @@ function publicValue(item, name) {
     const raw = item.values?.[name];
     return typeof raw === "string" && raw.trim() ? raw.trim() : null;
 }
+function publicBoolean(item, name) {
+    if (!item || !isAvailable(item))
+        return false;
+    const raw = item.values?.[name];
+    return raw === "true";
+}
+function googleAdsSendTo(item) {
+    const id = publicValue(item, "GOOGLE_ADS_CONVERSION_ID");
+    const label = publicValue(item, "GOOGLE_ADS_PURCHASE_CONVERSION_LABEL");
+    if (!id || !label)
+        return null;
+    return `${id}/${label}`;
+}
 function buildStorefrontCoreConfig(input) {
     const stripe = integration(input.integrations, "stripe");
     const simplepay = integration(input.integrations, "simplepay");
@@ -27,11 +40,13 @@ function buildStorefrontCoreConfig(input) {
     const fogyasztobarat = integration(input.integrations, "fogyasztobarat");
     const googleAnalytics = integration(input.integrations, "google-analytics");
     const googleTagManager = integration(input.integrations, "google-tag-manager");
+    const googleAds = integration(input.integrations, "google-ads");
     const googleSearchConsole = integration(input.integrations, "google-search-console");
     const googleMerchant = integration(input.integrations, "google-merchant");
     const afterSalesEnabled = Boolean(input.afterSales.enabled);
     const analyticsEnabled = isAvailable(googleAnalytics) || isAvailable(googleTagManager);
     const merchantFeedEnabled = isAvailable(googleMerchant);
+    const googleAdsEnabled = isAvailable(googleAds);
     return {
         schema_version: 1,
         store: {
@@ -51,6 +66,7 @@ function buildStorefrontCoreConfig(input) {
             seo: true,
             analytics: analyticsEnabled,
             merchant_feed: merchantFeedEnabled,
+            google_ads: googleAdsEnabled,
         },
         account: {
             enabled: true,
@@ -153,6 +169,15 @@ function buildStorefrontCoreConfig(input) {
                 enabled: merchantFeedEnabled,
                 feed_endpoint: "/store/feeds/google-merchant.xml",
             },
+            google_ads: {
+                enabled: googleAdsEnabled,
+                consent_required: true,
+                conversion_id: publicValue(googleAds, "GOOGLE_ADS_CONVERSION_ID"),
+                purchase_conversion_label: publicValue(googleAds, "GOOGLE_ADS_PURCHASE_CONVERSION_LABEL"),
+                purchase_send_to: googleAdsSendTo(googleAds),
+                remarketing_enabled: publicBoolean(googleAds, "GOOGLE_ADS_REMARKETING_ENABLED"),
+                google_tag_manager_enabled: isAvailable(googleTagManager),
+            },
         },
         checkout: {
             payment_availability: checkout_contract_1.CHECKOUT_BEHAVIOR.payment_availability,
@@ -170,4 +195,4 @@ function buildStorefrontCoreConfig(input) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storefront-core-config.js","sourceRoot":"","sources":["../../../../src/core/storefront-core-config.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/core/version.d.ts

@@ -1,4 +1,4 @@
-export declare const CORE_VERSION = "1.3.0";
+export declare const CORE_VERSION = "1.5.0";
 export declare const CORE_API_CONTRACT_VERSION = "1.0";
 export declare const STOREFRONT_CORE_CONFIG_SCHEMA_VERSION = 1;
-export declare const CORE_DB_SCHEMA_VERSION = 5;
+export declare const CORE_DB_SCHEMA_VERSION = 6;

package/.medusa/server/src/core/version.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CORE_DB_SCHEMA_VERSION = exports.STOREFRONT_CORE_CONFIG_SCHEMA_VERSION = exports.CORE_API_CONTRACT_VERSION = exports.CORE_VERSION = void 0;
-exports.CORE_VERSION = "1.3.0";
+exports.CORE_VERSION = "1.5.0";
 exports.CORE_API_CONTRACT_VERSION = "1.0";
 exports.STOREFRONT_CORE_CONFIG_SCHEMA_VERSION = 1;
-exports.CORE_DB_SCHEMA_VERSION = 5;
+exports.CORE_DB_SCHEMA_VERSION = 6;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb3JlL3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQWEsUUFBQSxZQUFZLEdBQUcsT0FBTyxDQUFBO0FBQ3RCLFFBQUEseUJBQXlCLEdBQUcsS0FBSyxDQUFBO0FBQ2pDLFFBQUEscUNBQXFDLEdBQUcsQ0FBQyxDQUFBO0FBQ3pDLFFBQUEsc0JBQXNCLEdBQUcsQ0FBQyxDQUFBIn0=

package/.medusa/server/src/jobs/abandoned-cart-recovery.d.ts

@@ -0,0 +1,23 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+export default function abandonedCartRecovery(container: MedusaContainer): Promise<{
+    scanned: number;
+    sent: number;
+    delayHours?: undefined;
+} | {
+    scanned: number;
+    sent: number;
+    delayHours: number;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    scanned: number;
+    sent: number;
+    delayHours?: undefined;
+} | {
+    scanned: number;
+    sent: number;
+    delayHours: number;
+}>;
+export declare const config: {
+    name: string;
+    schedule: string;
+};

package/.medusa/server/src/jobs/abandoned-cart-recovery.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = abandonedCartRecovery;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const integration_settings_1 = require("../modules/integration-settings");
+const abandoned_cart_1 = require("../core/abandoned-cart");
+const PAGE_SIZE = 100;
+async function abandonedCartRecovery(container) {
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:abandoned-cart-recovery", () => runBatch(container), { timeout: 1, expire: 3300 });
+    }
+    catch (error) {
+        const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        logger.info(JSON.stringify({
+            event: "scheduled_job_skipped_locked",
+            job: "abandoned-cart-recovery",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const settingsStore = container.resolve(integration_settings_1.INTEGRATION_SETTINGS_MODULE);
+    const resolved = await (0, integration_settings_1.resolvedIntegrationEnvironment)(settingsStore, "abandoned-cart");
+    const settings = (0, abandoned_cart_1.normalizeAbandonedCartConfig)(resolved.env);
+    if (!resolved.enabled || !settings.enabled)
+        return { scanned: 0, sent: 0 };
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const cartService = container.resolve(utils_1.Modules.CART);
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const cutoff = new Date(Date.now() - settings.delayHours * 60 * 60 * 1000);
+    let cursor = null;
+    let scanned = 0;
+    let sent = 0;
+    while (true) {
+        const { data: carts } = await query.graph({
+            entity: "cart",
+            fields: [
+                "id",
+                "email",
+                "locale",
+                "currency_code",
+                "updated_at",
+                "completed_at",
+                "metadata",
+                "items.quantity",
+            ],
+            filters: {
+                updated_at: { $lte: cutoff },
+                email: { $ne: null },
+                completed_at: null,
+                ...(cursor ? { id: { $gt: cursor } } : {}),
+            },
+            pagination: {
+                take: PAGE_SIZE,
+                order: { id: "ASC" },
+            },
+        });
+        if (!carts.length)
+            break;
+        for (const cart of carts) {
+            cursor = cart.id;
+            scanned += 1;
+            if (!cart.email)
+                continue;
+            if (cart.completed_at)
+                continue;
+            if (!Array.isArray(cart.items) || !cart.items.some((item) => Number(item?.quantity) > 0))
+                continue;
+            if (cart.metadata?.abandoned_cart_recovery_sent_at)
+                continue;
+            try {
+                // Newsletter is the existing marketing-consent source of truth. Do not
+                // create a coupon or send a recovery message to unsubscribed addresses.
+                const subscriber = await (0, abandoned_cart_1.subscribedNewsletterRecipient)(container, cart.email);
+                if (!subscriber)
+                    continue;
+                const existingCoupon = settings.couponEnabled
+                    ? String(cart.metadata?.abandoned_cart_recovery_coupon_code || "").trim() || null
+                    : null;
+                const coupon = settings.couponEnabled && !existingCoupon
+                    ? await (0, abandoned_cart_1.issueAbandonedCartCoupon)({ container: container, cartId: cart.id, config: settings })
+                    : existingCoupon
+                        ? {
+                            id: cart.metadata?.abandoned_cart_recovery_promotion_id || null,
+                            code: existingCoupon,
+                            existing: true,
+                        }
+                        : null;
+                if (coupon?.code && !existingCoupon) {
+                    await cartService.updateCarts({
+                        id: cart.id,
+                        metadata: {
+                            abandoned_cart_recovery_coupon_code: coupon.code,
+                            abandoned_cart_recovery_promotion_id: coupon.id || null,
+                        },
+                    });
+                    cart.metadata = {
+                        ...(cart.metadata || {}),
+                        abandoned_cart_recovery_coupon_code: coupon.code,
+                        abandoned_cart_recovery_promotion_id: coupon.id || null,
+                    };
+                }
+                const result = await (0, abandoned_cart_1.sendAbandonedCartRecoveryEmail)({
+                    container: container,
+                    cart,
+                    config: settings,
+                    couponCode: coupon?.code || null,
+                });
+                if (result?.skipped && "reason" in result && result.reason === "not-subscribed")
+                    continue;
+                await cartService.updateCarts({
+                    id: cart.id,
+                    metadata: {
+                        abandoned_cart_recovery_sent_at: new Date().toISOString(),
+                        abandoned_cart_recovery_delay_hours: settings.delayHours,
+                        ...(coupon?.code ? {
+                            abandoned_cart_recovery_coupon_code: coupon.code,
+                            abandoned_cart_recovery_promotion_id: coupon.id || null,
+                        } : {}),
+                    },
+                });
+                if (!result?.skipped)
+                    sent += 1;
+            }
+            catch (error) {
+                logger.warn(`[abandoned-cart-recovery] ${cart.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (carts.length < PAGE_SIZE)
+            break;
+    }
+    return { scanned, sent, delayHours: settings.delayHours };
+}
+exports.config = { name: "abandoned-cart-recovery", schedule: "30 * * * *" };
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/jobs/back-in-stock-reconciliation.d.ts

@@ -0,0 +1,15 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+export default function backInStockReconciliation(container: MedusaContainer): Promise<{
+    scanned: number;
+    variants: number;
+    sent: number;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    scanned: number;
+    variants: number;
+    sent: number;
+}>;
+export declare const config: {
+    name: string;
+    schedule: string;
+};

package/.medusa/server/src/jobs/back-in-stock-reconciliation.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = backInStockReconciliation;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const back_in_stock_1 = require("../core/back-in-stock");
+const back_in_stock_2 = require("../modules/back-in-stock");
+const SUBSCRIPTION_PAGE_SIZE = 1_000;
+const VARIANT_BATCH_SIZE = 250;
+async function backInStockReconciliation(container) {
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:back-in-stock-reconciliation", () => runBatch(container), { timeout: 1, expire: 840 });
+    }
+    catch (error) {
+        const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        logger.info(JSON.stringify({
+            event: "scheduled_job_skipped_locked",
+            job: "back-in-stock-reconciliation",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const service = container.resolve(back_in_stock_2.BACK_IN_STOCK_MODULE);
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const locking = container.resolve("locking");
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    // Build the active waiting-list snapshot before changing any subscription
+    // statuses. This avoids offset pagination skipping rows as notifications turn
+    // active records into notified records during the dispatch phase.
+    const variantIds = new Set();
+    let scanned = 0;
+    for (let skip = 0;; skip += SUBSCRIPTION_PAGE_SIZE) {
+        const subscriptions = await service.listBackInStockSubscriptions({ status: "active" }, { take: SUBSCRIPTION_PAGE_SIZE, skip, order: { created_at: "ASC" } });
+        scanned += subscriptions.length;
+        for (const subscription of subscriptions) {
+            const variantId = String(subscription.variant_id || "").trim();
+            if (variantId)
+                variantIds.add(variantId);
+        }
+        if (subscriptions.length < SUBSCRIPTION_PAGE_SIZE)
+            break;
+    }
+    const ids = [...variantIds];
+    let sent = 0;
+    for (let offset = 0; offset < ids.length; offset += VARIANT_BATCH_SIZE) {
+        const batchIds = ids.slice(offset, offset + VARIANT_BATCH_SIZE);
+        const { data: variants } = await query.graph({
+            entity: "product_variant",
+            fields: [
+                "id",
+                "title",
+                "sku",
+                "manage_inventory",
+                "allow_backorder",
+                "metadata",
+                "product.id",
+                "product.title",
+                "product.handle",
+                "product.metadata",
+            ],
+            filters: { id: batchIds },
+        });
+        for (const variant of variants) {
+            try {
+                const result = await locking.execute(`back-in-stock:variant:${variant.id}`, () => (0, back_in_stock_1.dispatchBackInStockVariant)({
+                    container: container,
+                    query,
+                    variant,
+                }), { timeout: 1, expire: 300 });
+                sent += result.sent;
+            }
+            catch (error) {
+                logger.info(JSON.stringify({
+                    event: "back_in_stock_variant_skipped_or_failed",
+                    variant_id: variant.id,
+                    message: error instanceof Error ? error.message : String(error),
+                }));
+            }
+        }
+    }
+    return { scanned, variants: ids.length, sent };
+}
+exports.config = {
+    name: "back-in-stock-reconciliation",
+    schedule: "*/15 * * * *",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/jobs/dpd-statusdata-sync.d.ts

@@ -0,0 +1,17 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+export default function dpdStatusdataSync(container: MedusaContainer): Promise<{
+    files: number;
+    processedFiles: number;
+    records: number;
+    matched: number;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    files: number;
+    processedFiles: number;
+    records: number;
+    matched: number;
+}>;
+export declare const config: {
+    name: string;
+    schedule: string;
+};

package/.medusa/server/src/jobs/dpd-statusdata-sync.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = dpdStatusdataSync;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const dpd_1 = require("../providers/dpd");
+const integration_operation_1 = require("../modules/integration-operation");
+const state_1 = require("../modules/integration-operation/state");
+const shipping_1 = require("../lib/modules/shipping");
+async function dpdStatusdataSync(container) {
+    if (process.env.DPD_STATUSDATA_ENABLED !== "true")
+        return;
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:dpd-statusdata-sync", () => runBatch(container), { timeout: 1, expire: 14 * 60 });
+    }
+    catch (error) {
+        const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        logger.info(JSON.stringify({
+            event: "scheduled_job_skipped_locked",
+            job: "dpd-statusdata-sync",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const orderService = container.resolve("order");
+    const operationStore = container.resolve(integration_operation_1.INTEGRATION_OPERATION_MODULE);
+    const client = new dpd_1.DpdStatusdataFtpClient((0, dpd_1.dpdStatusdataFtpConfigFromEnv)());
+    const files = (await client.listFiles()).sort();
+    let processedFiles = 0;
+    let records = 0;
+    let matched = 0;
+    for (const filename of files) {
+        const acquired = await (0, state_1.acquireOperation)(operationStore, {
+            provider: "dpd",
+            operation_type: "statusdata.file",
+            entity_type: "statusdata_file",
+            entity_id: filename,
+            idempotency_key: `dpd:statusdata:file:${filename}`,
+            reference_data: {
+                replay_safe: true,
+                filename,
+            },
+        });
+        if (!acquired.acquired) {
+            if (acquired.operation.status === "succeeded")
+                continue;
+            logger.info(`[dpd-statusdata-sync] ${filename}: a fájl már feldolgozás alatt áll.`);
+            continue;
+        }
+        try {
+            const content = await client.readFile(filename);
+            const parsed = (0, dpd_1.parseDpdStatusdata)(content);
+            let fileMatched = 0;
+            let fileUnmatched = 0;
+            for (const record of parsed) {
+                const result = await (0, shipping_1.applyNormalizedTrackingEvent)({
+                    orderService,
+                    operationStore,
+                    event: (0, dpd_1.dpdStatusdataEvent)(record),
+                });
+                if (result)
+                    fileMatched += 1;
+                else
+                    fileUnmatched += 1;
+            }
+            if (fileUnmatched > 0) {
+                // Keep the file replayable. Rows already applied above are independently
+                // idempotent, so a later retry only has to match the previously missing rows.
+                throw new Error(`${fileUnmatched} DPD Statusdata eseményhez még nem található rendelés.`);
+            }
+            await (0, state_1.operationSucceeded)(operationStore, acquired.operation, filename, {
+                replay_safe: true,
+                filename,
+                record_count: parsed.length,
+                matched_count: fileMatched,
+                processed_at: new Date().toISOString(),
+            });
+            processedFiles += 1;
+            records += parsed.length;
+            matched += fileMatched;
+        }
+        catch (error) {
+            await (0, state_1.operationFailed)(operationStore, acquired.operation, error, false, filename, {
+                replay_safe: true,
+                filename,
+            });
+            logger.warn(`[dpd-statusdata-sync] ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        files: files.length,
+        processedFiles,
+        records,
+        matched,
+    };
+}
+// DPD Hungary generates Statusdata when statuses changed (hourly). Poll the
+// dedicated FTP every 15 minutes so a newly generated file is picked up quickly.
+exports.config = {
+    name: "dpd-statusdata-sync",
+    schedule: "*/15 * * * *",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/jobs/mpl-push-tracking.d.ts

@@ -0,0 +1,19 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+export default function mplPushTracking(container: MedusaContainer): Promise<{
+    records: number;
+    applied: number;
+    malformed: number;
+    unmatched: number;
+    lastRead: string | null;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    records: number;
+    applied: number;
+    malformed: number;
+    unmatched: number;
+    lastRead: string | null;
+}>;
+export declare const config: {
+    name: string;
+    schedule: string;
+};