@mercurjs/core 2.3.6-canary.0 → 2.3.6-canary.2

package/.medusa/server/src/patches/index.d.ts

@@ -4,4 +4,13 @@ export type ApplyPatchesOptions = {
     logger?: Pick<Console, "info" | "warn">;
 };
 export declare function applyMercurPatches(options?: ApplyPatchesOptions): void;
+export declare const DISABLED_PATCHES_ENV = "MERCUR_DISABLED_PATCHES";
+export declare function disabledPatchesFromEnv(env?: NodeJS.ProcessEnv): string[];
+export declare function ensureMercurPatches(options?: ApplyPatchesOptions): void;
+/**
+ * Patches are applied when `@mercurjs/core` is imported, which is before
+ * `withMercur()` can see its config. A patch listed only in the config was
+ * therefore applied anyway; say so instead of letting the opt-out silently fail.
+ */
+export declare function assertPatchesDisabled(requested?: string[]): void;
 export { PATCHES } from "./manifest";

package/.medusa/server/src/patches/index.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PATCHES = void 0;
+exports.PATCHES = exports.DISABLED_PATCHES_ENV = void 0;
 exports.applyMercurPatches = applyMercurPatches;
+exports.disabledPatchesFromEnv = disabledPatchesFromEnv;
+exports.ensureMercurPatches = ensureMercurPatches;
+exports.assertPatchesDisabled = assertPatchesDisabled;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const apply_patch_1 = require("./apply-patch");
@@ -15,9 +18,9 @@ const version_1 = require("./version");
 // mutually incompatible, and none of them reach a marketplace that installed
 // `@mercurjs/core` into an existing Medusa app.
 //
-// So the diffs live in `patches/` and are applied here, from `withMercur()`,
-// which every project calls. They travel with the package version and arrive on
-// a normal upgrade.
+// So the diffs live in `patches/` and are applied as a side effect of importing
+// `@mercurjs/core` (see `register.ts`). They travel with the package version and
+// arrive on a normal upgrade.
 //
 // Patches are applied in memory, never written to `node_modules`: a boot has no
 // business mutating installed packages, workers would race doing it, and a file
@@ -65,19 +68,19 @@ function applyToCopy(entry, copy, patchFilePath) {
     const paths = patched.map((file) => resolveFile(copy.dir, file.relativePath));
     const stale = paths.filter((path) => (0, loader_1.isAlreadyLoaded)(path) && !(0, loader_1.isOverridden)(path));
     (0, loader_1.registerOverrides)(copy.dir, patched, resolveFile);
-    // Something required these modules before `withMercur()` ran, so the cache
-    // holds their unpatched source. Evict them and compile the patched source in
-    // their place; a workflow module re-registers itself under the same id, which
-    // is what makes the patch take effect on an already-loaded package.
+    // Something required these modules before `@mercurjs/core` was loaded, so the
+    // cache holds their unpatched source. A workflow module re-registers itself
+    // under the same id, which is what makes the patch take effect on an
+    // already-loaded package.
     if (stale.length) {
-        (0, loader_1.purgeFiles)(stale);
-        (0, loader_1.reload)(copy.dir, stale);
+        (0, loader_1.replaceLoaded)(copy.dir, stale);
     }
     return true;
 }
 function applyMercurPatches(options = {}) {
     const disabled = new Set(options.disabled ?? []);
     const logger = options.logger ?? console;
+    const patchedPackages = new Set();
     for (const entry of manifest_1.PATCHES) {
         if (disabled.has(entry.file)) {
             logger.warn(`[mercur] Skipping patch "${entry.file}" (disabled). This restores the ` +
@@ -99,12 +102,52 @@ function applyMercurPatches(options = {}) {
         }
         logger.info(`[mercur] Applied patch "${entry.file}" to ${patchedCount} copy/copies of ` +
             `${entry.package}`);
-        // Load the patched package now rather than leaving it to Medusa: the
-        // override only bites on first require, so failing here keeps the failure
-        // next to the patch that caused it.
-        require(entry.package);
+        patchedPackages.add(entry.package);
     }
+    // Load the patched packages now rather than leaving it to Medusa: the
+    // override only bites on first require, so failing here keeps the failure
+    // next to the patches that caused it. Deferred until every patch is
+    // registered, because requiring a package after its first patch loads the
+    // files a later patch targets unpatched, and the package index keeps
+    // re-exporting those stale modules even after they are reloaded.
+    for (const packageName of patchedPackages) {
+        require(packageName);
+    }
+}
+// Keyed on the global symbol registry so that two installed copies of
+// `@mercurjs/core` — common under bun and pnpm — patch the process only once.
+const APPLIED = Symbol.for("@mercurjs/core/patches-applied");
+exports.DISABLED_PATCHES_ENV = "MERCUR_DISABLED_PATCHES";
+function disabledPatchesFromEnv(env = process.env) {
+    return (env[exports.DISABLED_PATCHES_ENV] ?? "")
+        .split(",")
+        .map((name) => name.trim())
+        .filter(Boolean);
+}
+function ensureMercurPatches(options = {}) {
+    const state = globalThis;
+    if (state[APPLIED])
+        return;
+    applyMercurPatches(options);
+    state[APPLIED] = { disabled: options.disabled ?? [] };
+}
+/**
+ * Patches are applied when `@mercurjs/core` is imported, which is before
+ * `withMercur()` can see its config. A patch listed only in the config was
+ * therefore applied anyway; say so instead of letting the opt-out silently fail.
+ */
+function assertPatchesDisabled(requested = []) {
+    const applied = globalThis[APPLIED];
+    if (!applied)
+        return;
+    const missed = requested.filter((name) => !applied.disabled.includes(name));
+    if (!missed.length)
+        return;
+    throw new Error(`[mercur] projectConfig.mercur.disabledPatches lists ${missed
+        .map((name) => `"${name}"`)
+        .join(", ")}, but patches are applied when @mercurjs/core is imported, ` +
+        `before the config is read. Set ${exports.DISABLED_PATCHES_ENV}="${requested.join(",")}" in the process environment instead.`);
 }
 var manifest_2 = require("./manifest");
 Object.defineProperty(exports, "PATCHES", { enumerable: true, get: function () { return manifest_2.PATCHES; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/patches/loader.d.ts

@@ -19,3 +19,13 @@ export declare function purgeFiles(absolutePaths: string[]): void;
  * correct outcome; `register` is swapped for the duration to say so.
  */
 export declare function reload(packageDir: string, absolutePaths: string[]): void;
+/**
+ * Evicts already-loaded files and compiles their patched source in place.
+ *
+ * Eviction alone does not reach code that required the package earlier: every
+ * index above a patched file re-exports it through a getter over the evicted
+ * module's `exports` object, so `require("@medusajs/core-flows")` keeps handing
+ * out the unpatched workflow. Copying the fresh exports onto that stale object
+ * is what makes the patch visible through the whole re-export chain.
+ */
+export declare function replaceLoaded(packageDir: string, absolutePaths: string[]): void;

package/.medusa/server/src/patches/loader.js

@@ -9,6 +9,7 @@ exports.isOverridden = isOverridden;
 exports.registerOverrides = registerOverrides;
 exports.purgeFiles = purgeFiles;
 exports.reload = reload;
+exports.replaceLoaded = replaceLoaded;
 const module_1 = __importDefault(require("module"));
 const path_1 = require("path");
 const internals = module_1.default;
@@ -56,9 +57,8 @@ function registerOverrides(packageDir, files, resolve) {
         overrides.set(resolve(packageDir, file.relativePath), file.source);
     }
 }
-// `withMercur()` runs from `medusa-config`, which is not always the first thing
-// to pull in a target package — `@medusajs/test-utils` requires core-flows
-// before it loads the config. A module already in the cache would keep its
+// `@mercurjs/core` is not always the first thing to pull in a target package —
+// `@medusajs/test-utils` requires core-flows before it loads the config. A module already in the cache would keep its
 // unpatched source forever, so the patched files are evicted and required again
 // through the override above.
 //
@@ -109,6 +109,48 @@ function reload(packageDir, absolutePaths) {
             manager.register = original;
     }
 }
+/**
+ * Evicts already-loaded files and compiles their patched source in place.
+ *
+ * Eviction alone does not reach code that required the package earlier: every
+ * index above a patched file re-exports it through a getter over the evicted
+ * module's `exports` object, so `require("@medusajs/core-flows")` keeps handing
+ * out the unpatched workflow. Copying the fresh exports onto that stale object
+ * is what makes the patch visible through the whole re-export chain.
+ */
+function replaceLoaded(packageDir, absolutePaths) {
+    const previous = new Map();
+    for (const filename of absolutePaths) {
+        previous.set(filename, require.cache[filename]?.exports);
+    }
+    purgeFiles(absolutePaths);
+    reload(packageDir, absolutePaths);
+    for (const [filename, stale] of previous) {
+        const fresh = require.cache[filename]?.exports;
+        if (isObject(stale) && isObject(fresh) && stale !== fresh) {
+            adoptExports(stale, fresh);
+        }
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function adoptExports(stale, fresh) {
+    for (const key of Object.keys(fresh)) {
+        const descriptor = Object.getOwnPropertyDescriptor(stale, key);
+        if (!descriptor || descriptor.configurable) {
+            Object.defineProperty(stale, key, {
+                configurable: true,
+                enumerable: true,
+                writable: true,
+                value: fresh[key],
+            });
+        }
+        else if (descriptor.writable) {
+            stale[key] = fresh[key];
+        }
+    }
+}
 // Resolved from the patched package, not from `@mercurjs/core`: bun and pnpm
 // give each dependent its own copy, and a `WorkflowManager` from a different
 // copy holds a different registry than the one `createWorkflow` writes to.
@@ -121,4 +163,4 @@ function loadWorkflowManager(packageDir) {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/patches/manifest.js

@@ -15,5 +15,15 @@ exports.PATCHES = [
             "is judged orphaned and checkout fails. The patch disables that cleanup. " +
             "See mercurjs/mercur#1442.",
     },
+    {
+        file: "@medusajs+core-flows@2.21.0-payment-hooks.patch",
+        package: "@medusajs/core-flows",
+        // Both targeted workflows are unchanged from 2.18.0 through 2.21.0.
+        compatible: { from: "2.18.0", to: "2.22.0" },
+        reason: "capturePaymentWorkflow and refundPaymentWorkflow end in an event and expose no " +
+            "hook, unlike createOrderWorkflow and cancelOrderWorkflow. A ledger that must " +
+            "record every capture and refund inside the movement's own transaction, with " +
+            "compensation, needs paymentCaptured and paymentRefunded.",
+    },
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuaWZlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGF0Y2hlcy9tYW5pZmVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFjYSxRQUFBLE9BQU8sR0FBaUI7SUFDbkM7UUFDRSxJQUFJLEVBQUUsbUNBQW1DO1FBQ3pDLE9BQU8sRUFBRSxzQkFBc0I7UUFDL0IscUVBQXFFO1FBQ3JFLFVBQVUsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLFFBQVEsRUFBRTtRQUM1QyxNQUFNLEVBQ0osdUVBQXVFO1lBQ3ZFLHNFQUFzRTtZQUN0RSwwRUFBMEU7WUFDMUUscUVBQXFFO1lBQ3JFLDBFQUEwRTtZQUMxRSwwRUFBMEU7WUFDMUUsMkJBQTJCO0tBQzlCO0NBQ0YsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuaWZlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGF0Y2hlcy9tYW5pZmVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFjYSxRQUFBLE9BQU8sR0FBaUI7SUFDbkM7UUFDRSxJQUFJLEVBQUUsbUNBQW1DO1FBQ3pDLE9BQU8sRUFBRSxzQkFBc0I7UUFDL0IscUVBQXFFO1FBQ3JFLFVBQVUsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLFFBQVEsRUFBRTtRQUM1QyxNQUFNLEVBQ0osdUVBQXVFO1lBQ3ZFLHNFQUFzRTtZQUN0RSwwRUFBMEU7WUFDMUUscUVBQXFFO1lBQ3JFLDBFQUEwRTtZQUMxRSwwRUFBMEU7WUFDMUUsMkJBQTJCO0tBQzlCO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsaURBQWlEO1FBQ3ZELE9BQU8sRUFBRSxzQkFBc0I7UUFDL0Isb0VBQW9FO1FBQ3BFLFVBQVUsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLFFBQVEsRUFBRTtRQUM1QyxNQUFNLEVBQ0osaUZBQWlGO1lBQ2pGLCtFQUErRTtZQUMvRSw4RUFBOEU7WUFDOUUsMERBQTBEO0tBQzdEO0NBQ0YsQ0FBQSJ9

package/.medusa/server/src/patches/patches/@medusajs+core-flows@2.21.0-payment-hooks.patch

@@ -0,0 +1,89 @@
+diff --git a/dist/payment/workflows/capture-payment.d.ts b/dist/payment/workflows/capture-payment.d.ts
+index 1b495fa..1e2fe8c 100644
+--- a/dist/payment/workflows/capture-payment.d.ts
++++ b/dist/payment/workflows/capture-payment.d.ts
+@@ -36,5 +36,11 @@ export declare const capturePaymentWorkflowId = "capture-payment-workflow";
+  *
+  * Capture a payment.
+  */
+-export declare const capturePaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<CapturePaymentWorkflowInput, PaymentDTO, []>;
++export declare const capturePaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<CapturePaymentWorkflowInput, PaymentDTO, [
++    import("@medusajs/framework/workflows-sdk").Hook<"paymentCaptured", {
++        payment: PaymentDTO;
++        order_id: string | null;
++        amount: BigNumberInput | null;
++    }, unknown>
++]>;
+ //# sourceMappingURL=capture-payment.d.ts.map
+
+diff --git a/dist/payment/workflows/capture-payment.js b/dist/payment/workflows/capture-payment.js
+index 404cfaf..e069e4d 100644
+--- a/dist/payment/workflows/capture-payment.js
++++ b/dist/payment/workflows/capture-payment.js
+@@ -54,6 +54,16 @@ exports.capturePaymentWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.cap
+         eventName: utils_1.PaymentEvents.CAPTURED,
+         data: { id: payment.id },
+     });
+-    return new workflows_sdk_1.WorkflowResponse(payment);
++    // MERCUR: payment has no hook where order has orderCreated / orderCanceled.
++    // A ledger that must record every capture in the capture's own transaction
++    // needs one; an event fires after commit and cannot be compensated.
++    const paymentCaptured = (0, workflows_sdk_1.createHook)("paymentCaptured", {
++        payment,
++        order_id: (0, workflows_sdk_1.transform)({ orderPayment }, ({ orderPayment }) => orderPayment?.order?.id ?? null),
++        amount: (0, workflows_sdk_1.transform)({ input }, ({ input }) => input.amount ?? null),
++    });
++    return new workflows_sdk_1.WorkflowResponse(payment, {
++        hooks: [paymentCaptured],
++    });
+ });
+ //# sourceMappingURL=capture-payment.js.map
+
+diff --git a/dist/payment/workflows/refund-payment.d.ts b/dist/payment/workflows/refund-payment.d.ts
+index 3848939..7ff118d 100644
+--- a/dist/payment/workflows/refund-payment.d.ts
++++ b/dist/payment/workflows/refund-payment.d.ts
+@@ -58,5 +58,17 @@ export declare const refundPaymentWorkflowId = "refund-payment-workflow";
+  *
+  * Refund a payment.
+  */
+-export declare const refundPaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<RefundPaymentWorkflowInput, any, []>;
++export declare const refundPaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<RefundPaymentWorkflowInput, any, [
++    import("@medusajs/framework/workflows-sdk").Hook<"paymentRefunded", {
++        payment: PaymentDTO;
++        order_id: string | null;
++        amount: BigNumberInput | null;
++        credit_line_amount: BigNumberInput;
++        refund_reason: {
++            id: string;
++            label: string;
++            code: string | null;
++        } | null;
++    }, unknown>
++]>;
+ //# sourceMappingURL=refund-payment.d.ts.map
+
+diff --git a/dist/payment/workflows/refund-payment.js b/dist/payment/workflows/refund-payment.js
+index 5d19f53..dcd8b37 100644
+--- a/dist/payment/workflows/refund-payment.js
++++ b/dist/payment/workflows/refund-payment.js
+@@ -145,6 +145,17 @@ exports.refundPaymentWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.refu
+         eventName: utils_1.PaymentEvents.REFUNDED,
+         data: { id: payment.id },
+     });
+-    return new workflows_sdk_1.WorkflowResponse(payment);
++    // MERCUR: see capture-payment.js. A refund is the correction side of a
++    // capture and needs the same in-transaction seam.
++    const paymentRefunded = (0, workflows_sdk_1.createHook)("paymentRefunded", {
++        payment: refundPayment,
++        order_id: (0, workflows_sdk_1.transform)({ order }, ({ order }) => order?.id ?? null),
++        amount: (0, workflows_sdk_1.transform)({ input }, ({ input }) => input.amount ?? null),
++        credit_line_amount: creditLineAmount,
++        refund_reason: (0, workflows_sdk_1.transform)({ refundReason }, ({ refundReason }) => refundReason ?? null),
++    });
++    return new workflows_sdk_1.WorkflowResponse(payment, {
++        hooks: [paymentRefunded],
++    });
+ });
+ //# sourceMappingURL=refund-payment.js.map
+

package/.medusa/server/src/patches/register.d.ts

@@ -0,0 +1 @@
+export {};

package/.medusa/server/src/patches/register.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+// A config's imports are evaluated before any call in it, so anything imported
+// next to `@mercurjs/core` in `medusa-config.ts` loads before `withMercur()` runs.
+// Patching has to happen here, on import: a workflow composed from unpatched
+// source never gains the hooks a patch adds, so a block that registers a hook
+// handler at import time would find it missing.
+(0, index_1.ensureMercurPatches)({ disabled: (0, index_1.disabledPatchesFromEnv)() });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGF0Y2hlcy9yZWdpc3Rlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLG1DQUFxRTtBQUVyRSwrRUFBK0U7QUFDL0UsbUZBQW1GO0FBQ25GLDZFQUE2RTtBQUM3RSw4RUFBOEU7QUFDOUUsZ0RBQWdEO0FBQ2hELElBQUEsMkJBQW1CLEVBQUMsRUFBRSxRQUFRLEVBQUUsSUFBQSw4QkFBc0IsR0FBRSxFQUFFLENBQUMsQ0FBQSJ9

package/.medusa/server/src/with-mercur.d.ts

@@ -1,3 +1,4 @@
+import "./patches/register";
 import type { InputConfigWithArrayModules } from "@medusajs/framework/types";
 type HttpConfig = NonNullable<NonNullable<InputConfigWithArrayModules["projectConfig"]>["http"]>;
 export type MercurInputConfig = Omit<InputConfigWithArrayModules, "projectConfig"> & {
@@ -7,9 +8,10 @@ export type MercurInputConfig = Omit<InputConfigWithArrayModules, "projectConfig
         };
         mercur?: {
             /**
-             * Patch file names to skip, e.g. "@medusajs+core-flows@2.18.0.patch".
-             * Each one restores an upstream bug, so only reach for this when a patch
-             * conflicts with your own override.
+             * @deprecated Patches are applied when `@mercurjs/core` is imported,
+             * before this config is read. Set `MERCUR_DISABLED_PATCHES` (comma
+             * separated) in the process environment instead; listing a patch only
+             * here fails the boot.
              */
             disabledPatches?: string[];
         };

package/.medusa/server/src/with-mercur.js

@@ -1,18 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withMercur = withMercur;
+require("./patches/register");
 const utils_1 = require("@medusajs/framework/utils");
 const patches_1 = require("./patches");
 const disable_medusa_middlewares_1 = require("./utils/disable-medusa-middlewares");
 function withMercur(config = {}) {
-    // Before `disableMedusaMiddlewares`, which requires Medusa middleware modules
-    // that pull in `@medusajs/core-flows` transitively. Patches are compiled on
-    // first require, so anything that loads the targeted modules must run after
-    // this. Medusa itself imports core-flows lazily, well after `medusa-config`
-    // is evaluated, which is what leaves this window open at all.
-    (0, patches_1.applyMercurPatches)({
-        disabled: config.projectConfig?.mercur?.disabledPatches,
-    });
+    (0, patches_1.assertPatchesDisabled)(config.projectConfig?.mercur?.disabledPatches);
     (0, disable_medusa_middlewares_1.disableMedusaMiddlewares)();
     const projectConfig = {
         ...config.projectConfig,
@@ -57,4 +51,4 @@ function withMercur(config = {}) {
         plugins,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/commission/workflows/refresh-order-commission-lines.d.ts

@@ -8,10 +8,17 @@ export declare const refreshOrderCommissionLinesWorkflowId = "refresh-order-comm
  * `setCommissionContext` receives the contexts built from the orders. A
  * handler returns `new StepResponse(contexts)` with `additional_context`
  * filled in, or nothing to leave the contexts as they are.
+ *
+ * `commissionLinesUpserted` runs after the lines are written, inside the same
+ * transaction, so a consumer's failure rolls the refresh back.
  */
 export type RefreshOrderCommissionLinesWorkflowHooks = [
     Hook<"setCommissionContext", {
         contexts: CommissionCalculationContext[];
-    }, CommissionCalculationContext[] | void>
+    }, CommissionCalculationContext[] | void>,
+    Hook<"commissionLinesUpserted", {
+        order_ids: string[];
+        commission_lines: CommissionLineDTO[];
+    }, unknown>
 ];
 export declare const refreshOrderCommissionLinesWorkflow: ReturnWorkflow<RefreshOrderCommissionLinesWorkflowInput, CommissionLineDTO[], RefreshOrderCommissionLinesWorkflowHooks>;

package/.medusa/server/src/workflows/commission/workflows/refresh-order-commission-lines.js

@@ -89,8 +89,12 @@ exports.refreshOrderCommissionLinesWorkflow = (0, workflows_sdk_1.createWorkflow
     const upsertedCommissionLines = (0, steps_1.upsertCommissionLinesStep)({
         commission_lines: commissionLines,
     });
+    const commissionLinesUpserted = (0, workflows_sdk_1.createHook)("commissionLinesUpserted", {
+        order_ids: input.order_ids,
+        commission_lines: upsertedCommissionLines,
+    });
     return new workflows_sdk_1.WorkflowResponse(upsertedCommissionLines, {
-        hooks: [setCommissionContext],
+        hooks: [setCommissionContext, commissionLinesUpserted],
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/index.d.ts

@@ -1,3 +1,4 @@
+import "../patches/register";
 export * from "./campaign";
 export * from "./customer-group";
 export * from "./commission";

package/.medusa/server/src/workflows/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+require("../patches/register");
 __exportStar(require("./campaign"), exports);
 __exportStar(require("./customer-group"), exports);
 __exportStar(require("./commission"), exports);
@@ -38,4 +39,4 @@ __exportStar(require("./media"), exports);
 __exportStar(require("./order"), exports);
 __exportStar(require("./review"), exports);
 __exportStar(require("./payment"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMEI7QUFDMUIsbURBQWdDO0FBQ2hDLCtDQUE0QjtBQUM1QiwyQ0FBd0I7QUFDeEIsbURBQWdDO0FBQ2hDLGdEQUE2QjtBQUM3QiwrQ0FBNEI7QUFDNUIsOENBQTJCO0FBQzNCLG1EQUFnQztBQUNoQywyQ0FBd0I7QUFDeEIsMkNBQXdCO0FBQ3hCLG9EQUFpQztBQUNqQyxtREFBZ0M7QUFDaEMseUNBQXNCO0FBQ3RCLDJDQUF3QjtBQUN4QixrREFBK0I7QUFDL0IsNENBQXlCO0FBQ3pCLHNEQUFtQztBQUNuQyxpREFBOEI7QUFDOUIsMENBQXVCO0FBQ3ZCLDBDQUF1QjtBQUN2QiwwQ0FBdUI7QUFDdkIsMkNBQXdCO0FBQ3hCLDRDQUF5QiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwrQkFBNEI7QUFFNUIsNkNBQTBCO0FBQzFCLG1EQUFnQztBQUNoQywrQ0FBNEI7QUFDNUIsMkNBQXdCO0FBQ3hCLG1EQUFnQztBQUNoQyxnREFBNkI7QUFDN0IsK0NBQTRCO0FBQzVCLDhDQUEyQjtBQUMzQixtREFBZ0M7QUFDaEMsMkNBQXdCO0FBQ3hCLDJDQUF3QjtBQUN4QixvREFBaUM7QUFDakMsbURBQWdDO0FBQ2hDLHlDQUFzQjtBQUN0QiwyQ0FBd0I7QUFDeEIsa0RBQStCO0FBQy9CLDRDQUF5QjtBQUN6QixzREFBbUM7QUFDbkMsaURBQThCO0FBQzlCLDBDQUF1QjtBQUN2QiwwQ0FBdUI7QUFDdkIsMENBQXVCO0FBQ3ZCLDJDQUF3QjtBQUN4Qiw0Q0FBeUIifQ==

package/.medusa/server/src/workflows/order/workflows/confirm-return-receive.d.ts

@@ -1,7 +1,20 @@
-import { OrderPreviewDTO } from "@medusajs/framework/types";
+import { BigNumberInput, OrderPreviewDTO } from "@medusajs/framework/types";
+import { Hook } from "@medusajs/framework/workflows-sdk";
 export type ConfirmReceiveReturnRequestWorkflowInput = {
     return_id: string;
     confirmed_by?: string;
 };
 export declare const confirmReturnReceiveWorkflowId = "mercur-confirm-return-receive";
-export declare const confirmReturnReceiveWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<ConfirmReceiveReturnRequestWorkflowInput, OrderPreviewDTO, []>;
+export type ConfirmReturnReceiveWorkflowHooks = [
+    Hook<"returnReceived", {
+        order_id: string;
+        return_id: string;
+        seller_id: string | null;
+        items: {
+            id: string;
+            received_quantity: BigNumberInput;
+            damaged_quantity: BigNumberInput;
+        }[];
+    }, unknown>
+];
+export declare const confirmReturnReceiveWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<ConfirmReceiveReturnRequestWorkflowInput, OrderPreviewDTO, ConfirmReturnReceiveWorkflowHooks>;

package/.medusa/server/src/workflows/order/workflows/confirm-return-receive.js

@@ -94,7 +94,7 @@ exports.confirmReturnReceiveWorkflow = (0, workflows_sdk_1.createWorkflow)(expor
     });
     const order = (0, core_flows_1.useRemoteQueryStep)({
         entry_point: "orders",
-        fields: ["id", "version", "canceled_at"],
+        fields: ["id", "version", "canceled_at", "seller.id"],
         variables: { id: orderReturn.order_id },
         list: false,
         throw_if_key_not_found: true,
@@ -207,6 +207,17 @@ exports.confirmReturnReceiveWorkflow = (0, workflows_sdk_1.createWorkflow)(expor
             return_id: orderReturn.id,
         },
     }));
-    return new workflows_sdk_1.WorkflowResponse((0, core_flows_1.previewOrderChangeStep)(order.id));
+    const sellerId = (0, workflows_sdk_1.transform)({ order }, ({ order }) => {
+        return order.seller?.id ?? null;
+    });
+    const returnReceived = (0, workflows_sdk_1.createHook)("returnReceived", {
+        order_id: order.id,
+        return_id: orderReturn.id,
+        seller_id: sellerId,
+        items: updateReturnItem,
+    });
+    return new workflows_sdk_1.WorkflowResponse((0, core_flows_1.previewOrderChangeStep)(order.id), {
+        hooks: [returnReceived],
+    });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirm-return-receive.js","sourceRoot":"","sources":["../../../../../../src/workflows/order/workflows/confirm-return-receive.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirm-return-receive.js","sourceRoot":"","sources":["../../../../../../src/workflows/order/workflows/confirm-return-receive.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/workflows/payment/workflows/index.d.ts

@@ -1 +1,2 @@
 export * from "./process-payment";
+export * from "./payment-hooks";

package/.medusa/server/src/workflows/payment/workflows/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./process-payment"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3BheW1lbnQvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUMifQ==
+__exportStar(require("./payment-hooks"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3BheW1lbnQvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUM7QUFDakMsa0RBQStCIn0=

package/.medusa/server/src/workflows/payment/workflows/payment-hooks.d.ts

@@ -0,0 +1,25 @@
+import type { BigNumberInput, PaymentDTO } from "@medusajs/framework/types";
+import type { Hook, ReturnWorkflow } from "@medusajs/framework/workflows-sdk";
+import { type CapturePaymentWorkflowInput, type RefundPaymentWorkflowInput } from "@medusajs/medusa/core-flows";
+export type CapturePaymentWorkflowHooks = [
+    Hook<"paymentCaptured", {
+        payment: PaymentDTO;
+        order_id: string | null;
+        amount: BigNumberInput | null;
+    }, unknown>
+];
+export type RefundPaymentWorkflowHooks = [
+    Hook<"paymentRefunded", {
+        payment: PaymentDTO;
+        order_id: string | null;
+        amount: BigNumberInput | null;
+        credit_line_amount: BigNumberInput;
+        refund_reason: {
+            id: string;
+            label: string;
+            code: string | null;
+        } | null;
+    }, unknown>
+];
+export declare const capturePaymentWorkflow: ReturnWorkflow<CapturePaymentWorkflowInput, PaymentDTO, CapturePaymentWorkflowHooks>;
+export declare const refundPaymentWorkflow: ReturnWorkflow<RefundPaymentWorkflowInput, PaymentDTO, RefundPaymentWorkflowHooks>;

package/.medusa/server/src/workflows/payment/workflows/payment-hooks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refundPaymentWorkflow = exports.capturePaymentWorkflow = void 0;
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+// The hooks come from the core-flows payment-hooks patch, which is applied in
+// memory and cannot reach Medusa's shipped typings, so the patched shape is
+// asserted here. Keep in sync with patches/@medusajs+core-flows@*-payment-hooks.patch.
+exports.capturePaymentWorkflow = core_flows_1.capturePaymentWorkflow;
+exports.refundPaymentWorkflow = core_flows_1.refundPaymentWorkflow;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bWVudC1ob29rcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvcGF5bWVudC93b3JrZmxvd3MvcGF5bWVudC1ob29rcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSw0REFLb0M7QUE0QnBDLDhFQUE4RTtBQUM5RSw0RUFBNEU7QUFDNUUsdUZBQXVGO0FBQzFFLFFBQUEsc0JBQXNCLEdBQ2pDLG1DQUlDLENBQUE7QUFFVSxRQUFBLHFCQUFxQixHQUNoQyxrQ0FJQyxDQUFBIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercurjs/core",
-  "version": "2.3.6-canary.0",
+  "version": "2.3.6-canary.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/mercurjs/mercur",
@@ -61,7 +61,7 @@
     "@medusajs/medusa": "2.21.0",
     "@medusajs/test-utils": "2.21.0",
     "@medusajs/ui": "4.2.3",
-    "@mercurjs/types": "2.3.6-canary.0",
+    "@mercurjs/types": "2.3.6-canary.2",
     "@swc/core": "^1.7.28",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
@@ -80,7 +80,7 @@
     "multer": "^2.0.2",
     "http-proxy-middleware": "^3.0.3",
     "jsonwebtoken": "^9.0.3",
-    "@mercurjs/cli": "2.3.6-canary.0"
+    "@mercurjs/cli": "2.3.6-canary.2"
   },
   "peerDependencies": {
     "@medusajs/admin-sdk": ">=2.21.0",