@hszrdm/core 1.4.0 → 1.5.0

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;
+};

package/.medusa/server/src/jobs/mpl-push-tracking.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = mplPushTracking;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const mpl_1 = require("../providers/mpl");
+const integration_operation_1 = require("../modules/integration-operation");
+const shipping_1 = require("../lib/modules/shipping");
+const STATE_KEY = "mpl:tracking:push:subscription";
+const TOKEN_RENEW_AFTER_MS = 23 * 60 * 60 * 1000;
+async function mplPushTracking(container) {
+    if (process.env.MPL_ENABLED !== "true" ||
+        process.env.MPL_PUSH_TRACKING_ENABLED !== "true") {
+        return;
+    }
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:mpl-push-tracking", () => 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: "mpl-push-tracking",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const operationStore = container.resolve(integration_operation_1.INTEGRATION_OPERATION_MODULE);
+    const orderService = container.resolve("order");
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const state = await loadOrCreateState(operationStore);
+    const reference = state.reference_data && typeof state.reference_data === "object"
+        ? state.reference_data
+        : {};
+    let subscriptionToken = text(reference.subscription_token);
+    let subscribedAt = dateValue(reference.subscribed_at);
+    let lastRead = text(reference.last_read) || undefined;
+    const tokenExpired = !subscriptionToken || !subscribedAt ||
+        Date.now() - subscribedAt.getTime() >= TOKEN_RENEW_AFTER_MS;
+    if (tokenExpired) {
+        subscriptionToken = await mpl_1.mplService.client.subscribePushTracking();
+        subscribedAt = new Date();
+        // lastRead is intentionally preserved across subscription renewal. MPL keeps
+        // events for 24 hours and officially supports reconnecting with lastRead.
+    }
+    const records = await mpl_1.mplService.client.readPushTracking(subscriptionToken, lastRead);
+    let applied = 0;
+    let malformed = 0;
+    let unmatched = 0;
+    let newestLastRead = lastRead;
+    let blockedPackageId;
+    let blockedInsertedAt;
+    for (const record of records) {
+        const packageId = text(record.PackageId);
+        const insertedAt = text(record.InsertedAt) || undefined;
+        if (!packageId) {
+            malformed += 1;
+            logger.warn("[mpl-push-tracking] MPL PUSH rekord PackageId nélkül; a rekord kihagyva.");
+            // A malformed provider record can never be correlated. Advancing over it
+            // prevents one invalid record from permanently blocking the stream.
+            newestLastRead = laterTimestamp(newestLastRead, insertedAt) || newestLastRead;
+            continue;
+        }
+        const occurredAt = text(record.EventDateTime) || undefined;
+        const status = (0, shipping_1.mapMplPushStatus)(record.PackageStatus, record.PackageStatusText);
+        const result = await (0, shipping_1.applyNormalizedTrackingEvent)({
+            orderService,
+            operationStore,
+            event: {
+                carrier: "mpl",
+                shipmentIdentifiers: [packageId],
+                status,
+                rawStatus: text(record.PackageStatus) || null,
+                statusText: text(record.PackageStatusText) || null,
+                occurredAt: occurredAt || insertedAt || null,
+                eventId: text(record.TrackingRecordId) || null,
+                source: "push",
+                trackingNumber: packageId,
+                extra: {
+                    lastEvent: text(record.PackageStatusText) || undefined,
+                    lastEventCategory: text(record.PackageStatus) || undefined,
+                    lastEventAt: occurredAt || insertedAt,
+                    trackingSource: "push",
+                    eventPlace: text(record.EventPlace) || undefined,
+                    insertedAt,
+                },
+            },
+        });
+        if (!result) {
+            // Do not checkpoint past an event whose order is not visible yet. On the
+            // next reconnect MPL replays it from lastRead; the failed event operation
+            // itself is retry-safe through the existing idempotency machinery.
+            unmatched += 1;
+            blockedPackageId = packageId;
+            blockedInsertedAt = insertedAt;
+            break;
+        }
+        applied += 1;
+        newestLastRead = laterTimestamp(newestLastRead, insertedAt) || newestLastRead;
+    }
+    await operationStore.updateIntegrationOperations({
+        id: state.id,
+        status: "succeeded",
+        error_summary: unmatched
+            ? "Az MPL PUSH cursor egy még nem párosítható esemény előtt megállt; a következő futás újrapróbálja."
+            : null,
+        completed_at: new Date(),
+        reference_data: {
+            replay_safe: true,
+            subscription_token: subscriptionToken,
+            subscribed_at: subscribedAt?.toISOString() || new Date().toISOString(),
+            last_read: newestLastRead || null,
+            last_poll_at: new Date().toISOString(),
+            last_record_count: records.length,
+            last_applied_count: applied,
+            last_malformed_count: malformed,
+            last_unmatched_count: unmatched,
+            blocked_package_id: blockedPackageId || null,
+            blocked_inserted_at: blockedInsertedAt || null,
+        },
+    });
+    return {
+        records: records.length,
+        applied,
+        malformed,
+        unmatched,
+        lastRead: newestLastRead || null,
+    };
+}
+async function loadOrCreateState(store) {
+    const [existing] = await store.listIntegrationOperations({ idempotency_key: STATE_KEY }, { take: 1 });
+    if (existing)
+        return existing;
+    try {
+        return await store.createIntegrationOperations({
+            provider: "mpl",
+            operation_type: "tracking.push.subscription",
+            entity_type: "tracking_subscription",
+            entity_id: "global",
+            idempotency_key: STATE_KEY,
+            status: "succeeded",
+            attempts: 1,
+            error_summary: null,
+            next_attempt_at: null,
+            completed_at: new Date(),
+            reference_data: { replay_safe: true },
+        });
+    }
+    catch (error) {
+        const [raced] = await store.listIntegrationOperations({ idempotency_key: STATE_KEY }, { take: 1 });
+        if (raced)
+            return raced;
+        throw error;
+    }
+}
+function text(value) {
+    return value == null ? "" : String(value).trim();
+}
+function dateValue(value) {
+    const date = value ? new Date(String(value)) : null;
+    return date && !Number.isNaN(date.getTime()) ? date : null;
+}
+function laterTimestamp(left, right) {
+    if (!right)
+        return left;
+    if (!left)
+        return right;
+    const leftTime = Date.parse(left);
+    const rightTime = Date.parse(right);
+    if (!Number.isFinite(leftTime))
+        return right;
+    if (!Number.isFinite(rightTime))
+        return left;
+    return rightTime > leftTime ? right : left;
+}
+exports.config = {
+    name: "mpl-push-tracking",
+    schedule: "*/15 * * * *",
+};
+//# sourceMappingURL=data:application/json;base64,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