@hartl-services/medusa-base 0.1.1 → 0.3.0

package/.medusa/server/src/public/complete-cart.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxldGUtY2FydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wdWJsaWMvY29tcGxldGUtY2FydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/.medusa/server/src/public/sentry-logger.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSentryErrorReporting = withSentryErrorReporting;
+const Sentry = __importStar(require("@sentry/node"));
+/**
+ * Medusa's own HTTP error-handler middleware fully "handles" every thrown
+ * route/workflow error via logger.error(...) before it can ever reach an
+ * uncaught-exception process hook, so Sentry's default Node integrations
+ * never see it. Bridging logger.error(...) itself is the only place that
+ * reliably captures every error Medusa's framework already logs internally.
+ * Errors that Medusa logs through logger.warn(err) (failing event
+ * subscribers) are reported too, at warning level.
+ */
+function withSentryErrorReporting(logger) {
+    const originalError = logger.error.bind(logger);
+    const originalWarn = logger.warn.bind(logger);
+    return {
+        panic: logger.panic.bind(logger),
+        shouldLog: logger.shouldLog.bind(logger),
+        setLogLevel: logger.setLogLevel.bind(logger),
+        unsetLogLevel: logger.unsetLogLevel.bind(logger),
+        activity: logger.activity.bind(logger),
+        progress: logger.progress.bind(logger),
+        failure: logger.failure.bind(logger),
+        success: logger.success.bind(logger),
+        silly: logger.silly.bind(logger),
+        debug: logger.debug.bind(logger),
+        verbose: logger.verbose.bind(logger),
+        http: logger.http.bind(logger),
+        info: logger.info.bind(logger),
+        // Medusa's Redis Event Bus logs a failing subscriber's exception with
+        // warn(err), even on the final retry, so an Error passed to warn is a real
+        // failure too. Plain warning messages stay out of Sentry.
+        warn: (message) => {
+            if (message instanceof Error) {
+                Sentry.captureException(message, { level: "warning" });
+            }
+            return originalWarn(message);
+        },
+        log: logger.log.bind(logger),
+        error: (messageOrError, error) => {
+            const exception = error ?? (messageOrError instanceof Error ? messageOrError : new Error(messageOrError));
+            const loggerMessage = error && typeof messageOrError === "string" ? messageOrError : undefined;
+            Sentry.captureException(exception, loggerMessage ? { extra: { loggerMessage } } : undefined);
+            return originalError(messageOrError, error);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/utils/discover-complete-cart-participants.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectCompleteCartParticipants = selectCompleteCartParticipants;
+exports.listCompleteCartParticipants = listCompleteCartParticipants;
+const utils_1 = require("@medusajs/framework/utils");
+const discover_plugin_features_1 = require("./discover-plugin-features");
+const HOOK_NAMES = [
+    "validate",
+    "orderCreated",
+];
+const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const invalid = (moduleKey, reason) => new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Modul "${moduleKey}" deklariert ungültige Complete-Cart-Hooks: ${reason}`);
+const readDeclarations = (moduleKey, service) => {
+    if (service === null || typeof service !== "object") {
+        return undefined;
+    }
+    const declare = service
+        .completeCartHooks;
+    if (typeof declare !== "function") {
+        return undefined;
+    }
+    let declarations;
+    try {
+        declarations = declare.call(service);
+    }
+    catch (error) {
+        throw invalid(moduleKey, error instanceof Error ? error.message : String(error));
+    }
+    if (declarations === null ||
+        typeof declarations !== "object" ||
+        Array.isArray(declarations)) {
+        throw invalid(moduleKey, "completeCartHooks() liefert kein Objekt.");
+    }
+    return declarations;
+};
+const validateStep = (moduleKey, hook, step) => {
+    if (!HOOK_NAMES.includes(hook)) {
+        throw invalid(moduleKey, `unbekannter Hook "${hook}".`);
+    }
+    const candidate = step;
+    if (candidate === null ||
+        typeof candidate !== "object" ||
+        typeof candidate.workflow_id !== "string" ||
+        !candidate.workflow_id.trim() ||
+        typeof candidate.order !== "number" ||
+        !Number.isFinite(candidate.order)) {
+        throw invalid(moduleKey, `"${hook}" braucht eine workflow_id (String) und eine endliche order (Zahl).`);
+    }
+    return { workflow_id: candidate.workflow_id, order: candidate.order };
+};
+/**
+ * Selects the participants of one hook from the given modules: every service
+ * with a `completeCartHooks()` function. Fails closed: an invalid declaration
+ * (for any hook) is `UNEXPECTED_STATE`, never skipped. Sorted by `order`,
+ * then module key, then workflow id.
+ */
+function selectCompleteCartParticipants(modules, hook) {
+    const participants = [];
+    for (const { key, service } of modules) {
+        const declarations = readDeclarations(key, service);
+        if (!declarations) {
+            continue;
+        }
+        for (const [declaredHook, step] of Object.entries(declarations)) {
+            if (step === undefined) {
+                continue;
+            }
+            const valid = validateStep(key, declaredHook, step);
+            if (declaredHook === hook) {
+                participants.push({ module_key: key, ...valid });
+            }
+        }
+    }
+    participants.sort((left, right) => left.order - right.order ||
+        compare(left.module_key, right.module_key) ||
+        compare(left.workflow_id, right.workflow_id));
+    const workflowIds = new Set();
+    for (const participant of participants) {
+        if (workflowIds.has(participant.workflow_id)) {
+            throw invalid(participant.module_key, `Workflow "${participant.workflow_id}" ist für "${hook}" mehrfach deklariert.`);
+        }
+        workflowIds.add(participant.workflow_id);
+    }
+    return participants;
+}
+/** The participants of one hook among the modules registered in the app. */
+function listCompleteCartParticipants(container, hook) {
+    return selectCompleteCartParticipants((0, discover_plugin_features_1.listRegisteredModules)(container), hook);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/utils/discover-plugin-features.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listRegisteredModules = listRegisteredModules;
 exports.discoverPluginFeatureDescriptors = discoverPluginFeatureDescriptors;
 exports.findPluginFeatureDescriptor = findPluginFeatureDescriptor;
 const utils_1 = require("@medusajs/framework/utils");
@@ -7,6 +8,16 @@ const descriptor_1 = require("../public/descriptor");
 // Keyed by the app's config object: stable for the process lifetime, unlike
 // `req.scope`, which is a new scope per request.
 const discovered = new WeakMap();
+const registeredModules = (container, configModule) => Object.keys(configModule.modules ?? {})
+    .filter((moduleKey) => container.hasRegistration(moduleKey))
+    .map((moduleKey) => ({
+    key: moduleKey,
+    service: container.resolve(moduleKey),
+}));
+/** Every module listed in medusa-config that is registered in the container. */
+function listRegisteredModules(container) {
+    return registeredModules(container, container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE));
+}
 const readDescriptor = (service) => service !== null && typeof service === "object" && "pluginFeatures" in service
     ? service.pluginFeatures
     : undefined;
@@ -21,11 +32,8 @@ function discoverPluginFeatureDescriptors(container) {
         return memo;
     }
     const byPluginKey = new Map();
-    for (const moduleKey of Object.keys(configModule.modules ?? {})) {
-        if (!container.hasRegistration(moduleKey)) {
-            continue;
-        }
-        const candidate = readDescriptor(container.resolve(moduleKey));
+    for (const { key: moduleKey, service } of registeredModules(container, configModule)) {
+        const candidate = readDescriptor(service);
         if (candidate === undefined) {
             continue;
         }
@@ -48,4 +56,4 @@ function discoverPluginFeatureDescriptors(container) {
 function findPluginFeatureDescriptor(container, pluginKey) {
     return discoverPluginFeatureDescriptors(container).find((descriptor) => descriptor.plugin_key === pluginKey);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/hooks/complete-cart-participants.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compensateCompleteCartOrderCreatedParticipants = exports.runCompleteCartOrderCreatedParticipants = exports.runCompleteCartValidateParticipants = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const discover_complete_cart_participants_1 = require("../../utils/discover-complete-cart-participants");
+const participantsFor = (hook, container, modules) => modules
+    ? (0, discover_complete_cart_participants_1.selectCompleteCartParticipants)(modules, hook)
+    : (0, discover_complete_cart_participants_1.listCompleteCartParticipants)(container, hook);
+const logError = (container, message) => {
+    try {
+        container
+            .resolve(utils_1.ContainerRegistrationKeys.LOGGER)
+            .error(message);
+    }
+    catch {
+        // Logging must not replace the original workflow outcome.
+    }
+};
+/**
+ * Cancels (compensates) one participant run by transaction id, also after it
+ * finished; the participant workflow must be stored with a retention time.
+ * Not `engine.cancel()`: in Medusa 2.19.0 it loads the transaction through a
+ * workflow runner without the container, so the participant's compensation
+ * cannot resolve its module. Built with the container like `runAsStep` does.
+ * Throws the participant's own compensation error, not "Unknown error".
+ */
+const cancelParticipant = async (workflowId, transactionId, container, sharedContext) => {
+    const workflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
+    if (!workflow) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Workflow "${workflowId}" is not registered.`);
+    }
+    const { transaction } = await workflow(container).cancel({
+        transactionId,
+        container,
+        context: { ...sharedContext },
+        throwOnError: false,
+    });
+    if (transaction.getState() !== utils_1.TransactionState.REVERTED) {
+        const [first] = transaction.getErrors();
+        throw (first?.error ??
+            new Error(`Workflow "${workflowId}" ended in state "${transaction.getState()}" instead of reverted.`));
+    }
+};
+const describeError = (error) => error instanceof Error
+    ? error.message
+    : typeof error?.message === "string"
+        ? error.message
+        : String(error);
+/**
+ * Runs every `validate` participant in order. No transaction id: validation
+ * writes nothing, so there is nothing to compensate. The first error is
+ * rethrown unchanged, keeping its MedusaError type for the HTTP status.
+ */
+const runCompleteCartValidateParticipants = async (input, context, modules) => {
+    const { container, ...sharedContext } = context;
+    const participants = participantsFor("validate", container, modules);
+    if (!participants.length) {
+        return new workflows_sdk_1.StepResponse(undefined);
+    }
+    const workflowEngine = container.resolve(utils_1.Modules.WORKFLOW_ENGINE);
+    for (const participant of participants) {
+        // The engine JSON-clones its options, so the container is never passed
+        // to run(); the engine uses the shared app container.
+        await workflowEngine.run(participant.workflow_id, {
+            input,
+            context: {
+                ...sharedContext,
+                preventReleaseEvents: true,
+            },
+            throwOnError: true,
+        });
+    }
+    return new workflows_sdk_1.StepResponse(undefined);
+};
+exports.runCompleteCartValidateParticipants = runCompleteCartValidateParticipants;
+/**
+ * Runs every `orderCreated` participant in order under the complete-cart
+ * transaction id. If participant k fails, participants 0..k-1 are cancelled
+ * in reverse order; a rollback failure is logged, and the ORIGINAL error is
+ * rethrown either way.
+ */
+const runCompleteCartOrderCreatedParticipants = async (input, context, modules) => {
+    const { container, ...sharedContext } = context;
+    const transactionId = context.transactionId;
+    if (!transactionId) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Complete-cart orderCreated hook ran without a transaction id.");
+    }
+    const participants = participantsFor("orderCreated", container, modules);
+    const workflowIds = participants.map(({ workflow_id }) => workflow_id);
+    if (!participants.length) {
+        return new workflows_sdk_1.StepResponse(undefined, {
+            transaction_id: transactionId,
+            workflow_ids: workflowIds,
+        });
+    }
+    const workflowEngine = container.resolve(utils_1.Modules.WORKFLOW_ENGINE);
+    const completed = [];
+    for (const participant of participants) {
+        try {
+            await workflowEngine.run(participant.workflow_id, {
+                input,
+                transactionId,
+                context: {
+                    ...sharedContext,
+                    preventReleaseEvents: true,
+                },
+                throwOnError: true,
+            });
+        }
+        catch (error) {
+            for (const done of [...completed].reverse()) {
+                try {
+                    await cancelParticipant(done.workflow_id, transactionId, container, sharedContext);
+                }
+                catch (rollbackError) {
+                    logError(container, `Complete-cart orderCreated rollback failed for module "${done.module_key}", workflow "${done.workflow_id}" (cart ${input.cart_id}, order ${input.order_id}, transaction ${transactionId}) after "${participant.workflow_id}" failed: ${describeError(rollbackError)}`);
+                }
+            }
+            throw error;
+        }
+        completed.push(participant);
+    }
+    return new workflows_sdk_1.StepResponse(undefined, {
+        transaction_id: transactionId,
+        workflow_ids: workflowIds,
+    });
+};
+exports.runCompleteCartOrderCreatedParticipants = runCompleteCartOrderCreatedParticipants;
+/**
+ * Cancels the participants in reverse order. Every participant is attempted;
+ * failures are logged and the first one is thrown so the parent compensation
+ * stays failed. `undefined` means the invoke already rolled back.
+ */
+const compensateCompleteCartOrderCreatedParticipants = async (compensation, context) => {
+    if (!compensation) {
+        return;
+    }
+    const { container, ...sharedContext } = context;
+    const workflowIds = [...compensation.workflow_ids].reverse();
+    if (!workflowIds.length) {
+        return;
+    }
+    let failed = false;
+    let firstFailure;
+    for (const workflowId of workflowIds) {
+        try {
+            await cancelParticipant(workflowId, compensation.transaction_id, container, sharedContext);
+        }
+        catch (error) {
+            logError(container, `Complete-cart orderCreated compensation failed for workflow "${workflowId}" (transaction ${compensation.transaction_id}): ${describeError(error)}`);
+            if (!failed) {
+                failed = true;
+                firstFailure = error;
+            }
+        }
+    }
+    if (failed) {
+        throw firstFailure;
+    }
+};
+exports.compensateCompleteCartOrderCreatedParticipants = compensateCompleteCartOrderCreatedParticipants;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/hooks/complete-cart.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const complete_cart_participants_1 = require("./complete-cart-participants");
+/**
+ * The ONLY registrations of these two hooks in the whole shop. Medusa 2.19.0
+ * throws "Cannot define multiple hook handlers" for a second handler
+ * (workflows-sdk dist/utils/composer/create-hook.js), so plugins declare
+ * `completeCartHooks()` on their module service instead and the base runs
+ * their workflows. The cart path never reads feature toggles.
+ */
+core_flows_1.completeCartWorkflow.hooks.validate((input, context) => (0, complete_cart_participants_1.runCompleteCartValidateParticipants)(input, context));
+// Medusa 2.19.0 creates this hook internally but omits it from complete cart's
+// public declaration. Keep the cast isolated to this version-specific edge.
+const { orderCreated } = core_flows_1.completeCartWorkflow.hooks;
+orderCreated((input, context) => (0, complete_cart_participants_1.runCompleteCartOrderCreatedParticipants)(input, context), complete_cart_participants_1.compensateCompleteCartOrderCreatedParticipants);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxldGUtY2FydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvaG9va3MvY29tcGxldGUtY2FydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUNBLDREQUFrRTtBQUdsRSw2RUFNcUM7QUFFckM7Ozs7OztHQU1HO0FBRUgsaUNBQW9CLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRSxDQUNyRCxJQUFBLGdFQUFtQyxFQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsQ0FDcEQsQ0FBQTtBQWFELCtFQUErRTtBQUMvRSw0RUFBNEU7QUFDNUUsTUFBTSxFQUFFLFlBQVksRUFBRSxHQUFHLGlDQUFvQixDQUFDLEtBRTdDLENBQUE7QUFFRCxZQUFZLENBQ1YsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLEVBQUUsQ0FBQyxJQUFBLG9FQUF1QyxFQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsRUFDM0UsMkVBQThDLENBQy9DLENBQUEifQ==

package/README.md

@@ -16,6 +16,9 @@ helpers that plugins use to enforce their toggles.
   values to the Admin.
 - Exports `definePluginFeatures`, `requirePluginFeature` and
   `isPluginFeatureEnabled` from `@hartl-services/medusa-base` for plugins.
+- Owns the `completeCartWorkflow` hooks `validate` and `orderCreated` and runs
+  the workflows that plugins declare for them (see "Complete-cart hook
+  composition").
 
 ## Installation in a shop
 
@@ -164,3 +167,89 @@ existing data.
 - Updates are optimistic: `expected_version` 0 creates the row, any other
   value updates exactly that version. A concurrent change answers 409; the
   Admin page reloads and shows a notice.
+
+## Complete-cart hook composition
+
+**Why.** Medusa 2.19.0 allows exactly one handler per workflow hook; a second
+registration throws "Cannot define multiple hook handlers" at boot. Several
+plugins need `completeCartWorkflow.hooks.validate` and the (undeclared, but
+existing) `orderCreated` hook, so the base registers both, once
+(`src/workflows/hooks/complete-cart.ts`), and runs the plugins' workflows.
+**A plugin must never register these two hooks itself.**
+
+**How a plugin participates.** Its module service implements
+`CompleteCartParticipant` (plain data, `import type` only):
+
+```ts
+import type { CompleteCartHookDeclarations } from "@hartl-services/medusa-base"
+
+class MyModuleService extends MedusaService({ /* … */ }) {
+  completeCartHooks(): CompleteCartHookDeclarations {
+    return {
+      validate: { workflow_id: "my-validate-complete-cart", order: 150 },
+      orderCreated: { workflow_id: "my-order-created", order: 150 },
+    }
+  }
+}
+```
+
+- A `validate` workflow receives `CompleteCartValidateInput` (`{ input, cart }`)
+  and fails the checkout by throwing (a `MedusaError` keeps its type, so
+  `NOT_ALLOWED`/`INVALID_DATA` answer 400). It must not write.
+- An `orderCreated` workflow receives `CompleteCartOrderCreatedInput`
+  (`{ order_id, cart_id }`) and must be compensable. Create it with
+  `store: true` and a `retentionTime` of at least three days (Medusa's own
+  `completeCartWorkflow` retention): the base cancels it by transaction id also
+  after it finished, and the in-memory workflow engine deletes an unstored
+  finished transaction.
+- The base discovers participants like feature descriptors (every module in
+  `medusa-config` that is registered in the container). Fail closed: an
+  invalid declaration (non-string or blank `workflow_id`, non-finite `order`,
+  unknown hook name, the same workflow twice for one hook) is
+  `UNEXPECTED_STATE` and blocks checkout, naming the module key.
+
+**Ordering.** Ascending `order`, then module key, then workflow id. In use:
+Affiliate 100 (`affiliate-validate-complete-cart`,
+`finalize-affiliate-order-attribution`), tax compliance 200
+(`freeze-tax-compliance-order-evidence`, `orderCreated` only).
+
+**Rollback semantics.**
+
+- `validate` participants run one after another without their own transaction
+  id (they write nothing). The first error stops the chain and is rethrown
+  unchanged.
+- `orderCreated` participants run one after another through the workflow
+  engine under the complete-cart transaction id, with the parent's event group
+  (`preventReleaseEvents`). If participant *k* fails, the base cancels
+  participants *k-1 … 0* in reverse order, logs every failed cancellation
+  (module key, workflow id, cart, order, transaction), and rethrows the
+  original error.
+- When a later complete-cart step fails, the hook's compensation cancels every
+  participant in reverse order, attempts all of them, logs each failure and
+  then throws the first one, so the complete-cart compensation stays failed
+  instead of silently leaving partial state.
+- The base never swallows a participant error and never reads toggles here.
+
+
+## Sentry logger wrapper
+
+`@hartl-services/medusa-base/sentry-logger` exports `withSentryErrorReporting(logger)`,
+formerly published as `@hartl-services/medusa-sentry-logger`. Medusa's HTTP
+error handler catches thrown route and workflow errors and only logs them, so
+Sentry's default Node integrations never see them; wrapping the logger reports
+every `logger.error(...)` and every `Error` passed to `logger.warn(...)` (at
+level `warning`). It is a plain library import for `medusa-config.ts`, not a
+Medusa plugin feature, and needs `@sentry/node` (an optional peer dependency):
+
+```ts
+import { logger } from "@medusajs/framework/logger";
+import { withSentryErrorReporting } from "@hartl-services/medusa-base/sentry-logger";
+
+module.exports = defineConfig({
+  logger: withSentryErrorReporting(logger),
+  // ...
+});
+```
+
+Initialize Sentry in `instrumentation.ts` as usual; without a `SENTRY_DSN` the
+wrapper is inert.

package/dist/public/complete-cart.d.ts

@@ -0,0 +1,21 @@
+import type { completeCartWorkflow } from "@medusajs/medusa/core-flows";
+/** The two complete-cart hooks the base composes (see README). */
+export type CompleteCartHookName = "validate" | "orderCreated";
+/** One participant workflow, run by id through the workflow engine. */
+export type CompleteCartParticipantStep = {
+    readonly workflow_id: string;
+    /** Lower runs first; ties sort by module key, then workflow id. */
+    readonly order: number;
+};
+export type CompleteCartHookDeclarations = Partial<Record<CompleteCartHookName, CompleteCartParticipantStep>>;
+/** Implemented by a plugin's module service. Plain data only: the base runs the workflows by id. */
+export interface CompleteCartParticipant {
+    completeCartHooks(): CompleteCartHookDeclarations;
+}
+/** Input of a `validate` participant workflow: `{ input, cart }`. */
+export type CompleteCartValidateInput = Parameters<Parameters<typeof completeCartWorkflow.hooks.validate>[0]>[0];
+/** Input of an `orderCreated` participant workflow. */
+export type CompleteCartOrderCreatedInput = {
+    order_id: string;
+    cart_id: string;
+};

package/dist/public/complete-cart.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/public/index.d.ts

@@ -3,3 +3,4 @@ export { definePluginFeatures } from "./descriptor";
 export { resolveEffectivePluginFeatures } from "./effective-features";
 export { isPluginFeatureEnabled, requirePluginFeature } from "./enforcement";
 export type { EffectivePluginFeatures, PluginFeatureDefinition, PluginFeatureDescriptor, PluginFeatureProvider, } from "./types";
+export type { CompleteCartHookDeclarations, CompleteCartHookName, CompleteCartOrderCreatedInput, CompleteCartParticipant, CompleteCartParticipantStep, CompleteCartValidateInput, } from "./complete-cart";

package/dist/public/sentry-logger.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "@medusajs/framework/types";
+/**
+ * Medusa's own HTTP error-handler middleware fully "handles" every thrown
+ * route/workflow error via logger.error(...) before it can ever reach an
+ * uncaught-exception process hook, so Sentry's default Node integrations
+ * never see it. Bridging logger.error(...) itself is the only place that
+ * reliably captures every error Medusa's framework already logs internally.
+ * Errors that Medusa logs through logger.warn(err) (failing event
+ * subscribers) are reported too, at warning level.
+ */
+export declare function withSentryErrorReporting(logger: Logger): Logger;

package/dist/public/sentry-logger.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSentryErrorReporting = withSentryErrorReporting;
+const Sentry = __importStar(require("@sentry/node"));
+/**
+ * Medusa's own HTTP error-handler middleware fully "handles" every thrown
+ * route/workflow error via logger.error(...) before it can ever reach an
+ * uncaught-exception process hook, so Sentry's default Node integrations
+ * never see it. Bridging logger.error(...) itself is the only place that
+ * reliably captures every error Medusa's framework already logs internally.
+ * Errors that Medusa logs through logger.warn(err) (failing event
+ * subscribers) are reported too, at warning level.
+ */
+function withSentryErrorReporting(logger) {
+    const originalError = logger.error.bind(logger);
+    const originalWarn = logger.warn.bind(logger);
+    return {
+        panic: logger.panic.bind(logger),
+        shouldLog: logger.shouldLog.bind(logger),
+        setLogLevel: logger.setLogLevel.bind(logger),
+        unsetLogLevel: logger.unsetLogLevel.bind(logger),
+        activity: logger.activity.bind(logger),
+        progress: logger.progress.bind(logger),
+        failure: logger.failure.bind(logger),
+        success: logger.success.bind(logger),
+        silly: logger.silly.bind(logger),
+        debug: logger.debug.bind(logger),
+        verbose: logger.verbose.bind(logger),
+        http: logger.http.bind(logger),
+        info: logger.info.bind(logger),
+        // Medusa's Redis Event Bus logs a failing subscriber's exception with
+        // warn(err), even on the final retry, so an Error passed to warn is a real
+        // failure too. Plain warning messages stay out of Sentry.
+        warn: (message) => {
+            if (message instanceof Error) {
+                Sentry.captureException(message, { level: "warning" });
+            }
+            return originalWarn(message);
+        },
+        log: logger.log.bind(logger),
+        error: (messageOrError, error) => {
+            const exception = error ?? (messageOrError instanceof Error ? messageOrError : new Error(messageOrError));
+            const loggerMessage = error && typeof messageOrError === "string" ? messageOrError : undefined;
+            Sentry.captureException(exception, loggerMessage ? { extra: { loggerMessage } } : undefined);
+            return originalError(messageOrError, error);
+        },
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hartl-services/medusa-base",
-  "version": "0.1.1",
-  "description": "Base plugin for Hartl Services Medusa shops: per-plugin feature toggles with a generic Admin settings page, a Store endpoint for storefronts, and enforcement helpers for plugin routes, subscribers and jobs.",
+  "version": "0.3.0",
+  "description": "Base plugin for Hartl Services Medusa shops: per-plugin feature toggles with a generic Admin settings page, a Store endpoint for storefronts, enforcement helpers, the complete-cart hook composition, and the Sentry logger wrapper.",
   "license": "MIT",
   "files": [
     ".medusa/server",
@@ -28,6 +28,11 @@
       "import": "./dist/public/index.js",
       "require": "./dist/public/index.js"
     },
+    "./sentry-logger": {
+      "types": "./dist/public/sentry-logger.d.ts",
+      "import": "./dist/public/sentry-logger.js",
+      "require": "./dist/public/sentry-logger.js"
+    },
     "./.medusa/server/src/modules/*": "./.medusa/server/src/modules/*/index.js",
     "./.medusa/server/src/*": "./.medusa/server/src/*",
     "./admin": {
@@ -41,12 +46,13 @@
     "@medusajs/js-sdk": "^2.19.0",
     "@medusajs/medusa": "^2.19.0",
     "@medusajs/ui": "^4.2.1",
+    "@sentry/node": "^10.74.0",
     "@tanstack/react-query": "^5.64.2",
     "react": "^18.3.1",
     "react-router-dom": "^7.18.2"
   },
   "dependencies": {
-    "@hartl-services/medusa-food-supplements-contracts": "^0.10.0"
+    "@hartl-services/medusa-food-supplements-contracts": "^0.11.0"
   },
   "devDependencies": {
     "@medusajs/admin-sdk": "2.19.0",
@@ -55,6 +61,7 @@
     "@medusajs/js-sdk": "2.19.0",
     "@medusajs/medusa": "2.19.0",
     "@medusajs/ui": "4.2.1",
+    "@sentry/node": "^10.74.0",
     "@swc/core": "^1.7.28",
     "@swc/jest": "^0.2.39",
     "@tanstack/react-query": "5.64.2",
@@ -72,6 +79,11 @@
   "engines": {
     "node": ">=20"
   },
+  "peerDependenciesMeta": {
+    "@sentry/node": {
+      "optional": true
+    }
+  },
   "scripts": {
     "build": "medusa plugin:build && tsc -p tsconfig.public.json",
     "dev": "medusa plugin:develop",