@hartl-services/medusa-base 0.3.0 → 0.4.0

package/.medusa/server/src/modules/plugin-features/service.js

@@ -17,7 +17,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/framework/utils");
 const effective_features_1 = require("../../public/effective-features");
+const shop_master_data_1 = require("../../public/shop-master-data");
+const plugin_settings_1 = require("./domain/plugin-settings");
+const plugin_action_runs_1 = require("./domain/plugin-action-runs");
+const secret_box_1 = require("./domain/secret-box");
+const plugin_action_run_1 = __importDefault(require("./models/plugin-action-run"));
 const plugin_feature_state_1 = __importDefault(require("./models/plugin-feature-state"));
+const plugin_setting_state_1 = __importDefault(require("./models/plugin-setting-state"));
+/** `undefined` when unset or empty; any other non-string fails closed. */
+const readSettingsSecret = (options) => {
+    const value = options?.settingsSecret;
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Die Option settingsSecret des Base-Plugins muss ein String sein.");
+    }
+    return value;
+};
+// One warning per undecryptable stored secret per process, not per read.
+const reportedUndecryptable = new Set();
 const toStored = (row) => {
     const features = {};
     if (row.features && typeof row.features === "object") {
@@ -29,13 +48,71 @@ const toStored = (row) => {
     }
     return { enabled: row.enabled, features, version: Number(row.version) };
 };
-const describe = (descriptor, stored) => {
+const toStoredSettings = (row) => ({
+    values: (0, plugin_settings_1.toStoredSettingValues)(row.values),
+    version: Number(row.version),
+});
+const describeSetting = (setting) => {
+    const { definition, source } = setting;
+    const base = {
+        key: definition.key,
+        label: definition.label,
+        description: definition.description ?? null,
+        required: definition.required === true,
+        is_set: source !== "none",
+        source,
+        invalidates: [...(definition.invalidates ?? [])],
+    };
+    switch (definition.type) {
+        case "secret":
+            return { ...base, type: "secret" };
+        case "select":
+            return {
+                ...base,
+                type: "select",
+                options: (definition.options ?? []).map((option) => ({
+                    value: option.value,
+                    label: option.label,
+                })),
+                default: typeof definition.default === "string" ? definition.default : null,
+                value: typeof setting.value === "string" ? setting.value : null,
+            };
+        case "number":
+            return {
+                ...base,
+                type: "number",
+                min: definition.min ?? null,
+                max: definition.max ?? null,
+                default: typeof definition.default === "number" ? definition.default : null,
+                value: typeof setting.value === "number" ? setting.value : null,
+            };
+        default:
+            return {
+                ...base,
+                type: definition.type,
+                default: definition.default ?? null,
+                value: setting.value ?? null,
+            };
+    }
+};
+const describeSettings = (descriptor, resolved, version) => {
+    const missing = (0, plugin_settings_1.missingSettingKeys)(resolved);
+    return {
+        plugin_key: descriptor.plugin_key,
+        version,
+        configured: missing.length === 0,
+        missing,
+        settings: resolved.map(describeSetting),
+    };
+};
+const describe = (descriptor, stored, settings) => {
     const states = (0, effective_features_1.resolvePluginFeatureStates)(descriptor, stored);
     return {
         plugin_key: descriptor.plugin_key,
         label: descriptor.label,
         description: descriptor.description ?? null,
         default_enabled: descriptor.default_enabled ?? true,
+        switchable: descriptor.switchable ?? true,
         enabled: states.enabled,
         version: stored?.version ?? 0,
         features: states.features.map((state) => ({
@@ -47,15 +124,50 @@ const describe = (descriptor, stored) => {
             enabled: state.enabled,
             effective_enabled: state.effective_enabled,
         })),
+        settings: settings.settings,
+        configured: settings.configured,
+        missing: settings.missing,
+        settings_version: settings.version,
+        actions: (descriptor.actions ?? []).map((action) => ({
+            key: action.key,
+            label: action.label,
+            description: action.description ?? null,
+            mode: action.mode,
+            confirm: action.confirm ?? null,
+        })),
+        admin_page: descriptor.admin_page ?? null,
     };
 };
+const requireTransaction = (sharedContext, what) => {
+    const manager = sharedContext.transactionManager;
+    if (!manager) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Für die Aktualisierung ${what} fehlt die Transaktion.`);
+    }
+    return manager;
+};
+const assertExpectedVersion = (expectedVersion) => {
+    if (!Number.isInteger(expectedVersion) || expectedVersion < 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "expected_version muss eine nicht-negative ganze Zahl sein.");
+    }
+};
 /**
- * Persists configured toggle values per plugin. The descriptor (declared by
- * the owning plugin) is always passed in; this module never imports plugins.
+ * Persists configured toggle values and runtime settings per plugin. The
+ * descriptor (declared by the owning plugin) is always passed in; this module
+ * never imports plugins.
  */
 class PluginFeaturesModuleService extends (0, utils_1.MedusaService)({
     PluginFeatureState: plugin_feature_state_1.default,
+    PluginSettingState: plugin_setting_state_1.default,
+    PluginActionRun: plugin_action_run_1.default,
 }) {
+    /** Medusa passes the plugin's options to its modules as `options`. */
+    constructor(cradle, options, ...rest) {
+        super(cradle, options, ...rest);
+        /** The base's own settings: the shop master data. */
+        this.pluginFeatures = shop_master_data_1.shopMasterDataDescriptor;
+        this.cradle_ = cradle;
+        this.settingsSecret_ = readSettingsSecret(options);
+    }
     async retrieveEffectiveFeatures(descriptor, sharedContext = {}) {
         const stored = await this.retrieveStored(descriptor.plugin_key, sharedContext);
         return (0, effective_features_1.resolveEffectivePluginFeatures)(descriptor, stored);
@@ -69,23 +181,23 @@ class PluginFeaturesModuleService extends (0, utils_1.MedusaService)({
         const storedByKey = new Map(rows.map((row) => [row.plugin_key, toStored(row)]));
         return descriptors.map((descriptor) => (0, effective_features_1.resolveEffectivePluginFeatures)(descriptor, storedByKey.get(descriptor.plugin_key) ?? null));
     }
-    async describePluginFeatures(descriptor, sharedContext = {}) {
+    /** Toggles plus settings (no secret values), actions and the Admin page. */
+    async describePluginFeatures(descriptor, fallback, sharedContext = {}) {
         const stored = await this.retrieveStored(descriptor.plugin_key, sharedContext);
-        return describe(descriptor, stored);
+        const settings = await this.retrieveStoredSettings(descriptor.plugin_key, sharedContext);
+        return describe(descriptor, stored, this.describeStoredSettings(descriptor, settings, fallback));
     }
     /**
      * Optimistic concurrency: `expected_version` 0 inserts the first row, any
      * other value updates exactly that version. A lost race is `CONFLICT`.
      */
-    async updatePluginFeatures(descriptor, input, sharedContext = {}) {
+    async updatePluginFeatures(descriptor, input, fallback, sharedContext = {}) {
         const features = (0, effective_features_1.validateFeatureUpdate)(descriptor, input.features);
-        if (!Number.isInteger(input.expected_version) || input.expected_version < 0) {
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "expected_version muss eine nicht-negative ganze Zahl sein.");
-        }
-        const manager = sharedContext.transactionManager;
-        if (!manager) {
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für die Aktualisierung der Funktionsschalter fehlt die Transaktion.");
+        assertExpectedVersion(input.expected_version);
+        if (descriptor.switchable === false && input.enabled !== true) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Plugin "${descriptor.plugin_key}" kann nicht ausgeschaltet werden.`);
         }
+        const manager = requireTransaction(sharedContext, "der Funktionsschalter");
         const featuresJson = JSON.stringify(features);
         const rows = input.expected_version === 0
             ? await manager.execute(`insert into "plugin_feature_state"
@@ -118,12 +230,253 @@ class PluginFeaturesModuleService extends (0, utils_1.MedusaService)({
         if (!saved) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, `Die Funktionsschalter für Plugin "${descriptor.plugin_key}" wurden zwischenzeitlich geändert.`);
         }
-        return describe(descriptor, toStored(saved));
+        const settings = await this.retrieveStoredSettings(descriptor.plugin_key, sharedContext);
+        return describe(descriptor, toStored(saved), this.describeStoredSettings(descriptor, settings, fallback));
+    }
+    /** Settings with value source; secret values are never included. */
+    async describePluginSettings(descriptor, fallback, sharedContext = {}) {
+        const stored = await this.retrieveStoredSettings(descriptor.plugin_key, sharedContext);
+        return this.describeStoredSettings(descriptor, stored, fallback);
+    }
+    /**
+     * Resolved settings for server-side consumers, secrets DECRYPTED. Never
+     * return this to an HTTP client.
+     */
+    async resolvePluginSettings(descriptor, fallback, sharedContext = {}) {
+        const stored = await this.retrieveStoredSettings(descriptor.plugin_key, sharedContext);
+        const resolved = this.resolveStoredSettings(descriptor, stored, fallback);
+        const values = {};
+        for (const setting of resolved) {
+            if (setting.value !== undefined) {
+                values[setting.definition.key] = setting.value;
+            }
+        }
+        const missing = (0, plugin_settings_1.missingSettingKeys)(resolved);
+        return { values, configured: missing.length === 0, missing };
+    }
+    /**
+     * Merges `values` into the stored settings in one transaction: `null`
+     * deletes a key, secrets are sealed, secrets not sent stay, keys the
+     * descriptor no longer declares are dropped. Optimistic concurrency like
+     * the toggles: a stale `expected_version` is `CONFLICT`.
+     */
+    async updatePluginSettings(descriptor, input, fallback, sharedContext = {}) {
+        const update = (0, plugin_settings_1.validateSettingsUpdate)(descriptor, input.values ?? {});
+        assertExpectedVersion(input.expected_version);
+        const manager = requireTransaction(sharedContext, "der Einstellungen");
+        const conflict = () => new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, `Die Einstellungen für Plugin "${descriptor.plugin_key}" wurden zwischenzeitlich geändert.`);
+        const [currentRow] = await manager.execute(`select "values", "version" from "plugin_setting_state"
+       where "plugin_key" = ? and "deleted_at" is null
+       for update`, [descriptor.plugin_key], "all");
+        const current = currentRow ? toStoredSettings(currentRow) : null;
+        if ((current?.version ?? 0) !== input.expected_version) {
+            throw conflict();
+        }
+        const keyMaterial = Object.keys(update).some((key) => update[key] !== null &&
+            descriptor.settings?.find((setting) => setting.key === key)?.type ===
+                "secret")
+            ? this.requireKeyMaterial()
+            : "";
+        const merged = (0, plugin_settings_1.mergeStoredSettings)(descriptor, current?.values ?? {}, update, (plaintext, key) => (0, secret_box_1.sealSecret)(plaintext, keyMaterial, (0, secret_box_1.secretBinding)(descriptor.plugin_key, key)));
+        const valuesJson = JSON.stringify(merged.values);
+        const rows = input.expected_version === 0
+            ? await manager.execute(`insert into "plugin_setting_state"
+               ("id", "plugin_key", "values", "version",
+                "created_at", "updated_at")
+             values (?, ?, ?::jsonb, 1, now(), now())
+             on conflict do nothing
+             returning "values", "version"`, [
+                (0, utils_1.generateEntityId)(undefined, "plgset"),
+                descriptor.plugin_key,
+                valuesJson,
+            ], "all")
+            : await manager.execute(`update "plugin_setting_state"
+             set "values" = ?::jsonb,
+                 "version" = ?,
+                 "updated_at" = now()
+             where "plugin_key" = ?
+               and "version" = ?
+               and "deleted_at" is null
+             returning "values", "version"`, [
+                valuesJson,
+                input.expected_version + 1,
+                descriptor.plugin_key,
+                input.expected_version,
+            ], "all");
+        const saved = rows[0];
+        if (!saved) {
+            throw conflict();
+        }
+        const toggles = await this.retrieveStored(descriptor.plugin_key, sharedContext);
+        return {
+            plugin: describe(descriptor, toggles, this.describeStoredSettings(descriptor, toStoredSettings(saved), fallback)),
+            changed_keys: merged.changed_keys,
+        };
+    }
+    /**
+     * Records a new `running` run unless the same action is already running
+     * (then `started: false` with that run). First persists runs that the
+     * stale rule declares dead as failed, so a lost run never blocks forever;
+     * this is the only place that writes the stale state.
+     */
+    async startPluginActionRun(input, sharedContext = {}) {
+        const manager = requireTransaction(sharedContext, "des Aktionslaufs");
+        await this.abortStaleRuns(manager, input.plugin_key, input.action_key);
+        const [inserted] = await manager.execute(`insert into "plugin_action_run"
+         ("id", "plugin_key", "action_key", "status", "started_at",
+          "triggered_by", "created_at", "updated_at")
+       values (?, ?, ?, 'running', now(), ?, now(), now())
+       on conflict do nothing
+       returning *`, [
+            (0, utils_1.generateEntityId)(undefined, "plgrun"),
+            input.plugin_key,
+            input.action_key,
+            input.triggered_by,
+        ], "all");
+        if (inserted) {
+            return { started: true, run: (0, plugin_action_runs_1.toRunRecord)(inserted) };
+        }
+        const [running] = await manager.execute(`select * from "plugin_action_run"
+       where "plugin_key" = ? and "action_key" = ?
+         and "status" = 'running' and "deleted_at" is null
+       limit 1`, [input.plugin_key, input.action_key], "all");
+        if (!running) {
+            // The running run finished between insert and select; rare, retryable.
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Diese Aktion läuft bereits.");
+        }
+        return { started: false, run: (0, plugin_action_runs_1.toRunRecord)(running) };
+    }
+    /**
+     * Records the outcome of a run. Returns `null` for an unknown run. Records
+     * the real outcome also when the stale rule had marked the run failed.
+     */
+    async finishPluginActionRun(runId, outcome, sharedContext = {}) {
+        const manager = requireTransaction(sharedContext, "des Aktionslaufs");
+        const columns = (0, plugin_action_runs_1.finishedRunColumns)(outcome);
+        const [row] = await manager.execute(`update "plugin_action_run"
+       set "status" = ?,
+           "message" = ?,
+           "result" = ?::jsonb,
+           "finished_at" = now(),
+           "updated_at" = now()
+       where "id" = ? and "deleted_at" is null
+       returning *`, [
+            columns.status,
+            columns.message,
+            columns.result === null ? null : JSON.stringify(columns.result),
+            runId,
+        ], "all");
+        return row ? (0, plugin_action_runs_1.toRunRecord)(row) : null;
+    }
+    /** Stores progress of a `running` run; `false` for an unknown or finished run. */
+    async reportPluginActionRunProgress(runId, progress, sharedContext = {}) {
+        const manager = requireTransaction(sharedContext, "des Aktionslaufs");
+        const rows = await manager.execute(`update "plugin_action_run"
+       set "progress" = ?::jsonb, "updated_at" = now()
+       where "id" = ? and "status" = 'running' and "deleted_at" is null
+       returning "id"`, [JSON.stringify(progress), runId], "all");
+        return rows.length > 0;
+    }
+    /**
+     * Latest runs of one action, newest first. Read-only: a run the stale rule
+     * declares dead is reported `failed` with "Abgebrochen (Neustart)" (and its
+     * last sign of life as `finished_at`), but only persisted as such by the
+     * next start attempt (`startPluginActionRun`).
+     */
+    async listRecentPluginActionRuns(pluginKey, actionKey, limit, sharedContext = {}) {
+        const manager = sharedContext.manager;
+        if (!manager) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für das Lesen der Aktionsläufe fehlt der EntityManager.");
+        }
+        const rows = await manager.execute(`with "runs" as (
+         select *,
+                ("status" = 'running'
+                 and "updated_at" < now() - make_interval(secs => ?)) as "stale"
+         from "plugin_action_run"
+         where "plugin_key" = ? and "action_key" = ? and "deleted_at" is null
+         order by "started_at" desc, "id" desc
+         limit ?
+       )
+       select "id", "plugin_key", "action_key",
+              case when "stale" then 'failed' else "status" end as "status",
+              "started_at",
+              case when "stale" then "updated_at" else "finished_at" end
+                as "finished_at",
+              "triggered_by",
+              case when "stale" then ? else "message" end as "message",
+              "progress", "result"
+       from "runs"
+       order by "started_at" desc, "id" desc`, [
+            plugin_action_runs_1.PLUGIN_ACTION_RUN_STALE_AFTER_MS / 1000,
+            pluginKey,
+            actionKey,
+            limit,
+            plugin_action_runs_1.PLUGIN_ACTION_RUN_ABORTED_MESSAGE,
+        ], "all");
+        return rows.map(plugin_action_runs_1.toRunRecord);
+    }
+    /**
+     * The lazy restart rule (see `isStaleRun`): a `running` run without start
+     * or progress for an hour will never finish and is marked failed.
+     */
+    async abortStaleRuns(manager, pluginKey, actionKey) {
+        await manager.execute(`update "plugin_action_run"
+       set "status" = 'failed',
+           "message" = ?,
+           "finished_at" = now(),
+           "updated_at" = now()
+       where "plugin_key" = ? and "action_key" = ?
+         and "status" = 'running' and "deleted_at" is null
+         and "updated_at" < now() - make_interval(secs => ?)`, [
+            plugin_action_runs_1.PLUGIN_ACTION_RUN_ABORTED_MESSAGE,
+            pluginKey,
+            actionKey,
+            plugin_action_runs_1.PLUGIN_ACTION_RUN_STALE_AFTER_MS / 1000,
+        ], "run");
+    }
+    describeStoredSettings(descriptor, stored, fallback) {
+        return describeSettings(descriptor, this.resolveStoredSettings(descriptor, stored, fallback), stored?.version ?? 0);
+    }
+    resolveStoredSettings(descriptor, stored, fallback) {
+        return (0, plugin_settings_1.resolveSettingValues)(descriptor, stored?.values ?? {}, fallback, (key, sealed) => this.tryOpen(descriptor.plugin_key, key, sealed));
+    }
+    /** `undefined` (logged once) when the secret cannot be decrypted. */
+    tryOpen(pluginKey, key, sealed) {
+        try {
+            return (0, secret_box_1.openSecret)(sealed, this.requireKeyMaterial(), (0, secret_box_1.secretBinding)(pluginKey, key));
+        }
+        catch (error) {
+            const marker = `${pluginKey}:${key}:${sealed}`;
+            if (!reportedUndecryptable.has(marker)) {
+                reportedUndecryptable.add(marker);
+                this.cradle_.logger?.warn(`Geheime Einstellung "${key}" von Plugin "${pluginKey}" kann nicht entschlüsselt werden und gilt als nicht gesetzt (wurde settingsSecret bzw. COOKIE_SECRET geändert?): ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return undefined;
+        }
+    }
+    /**
+     * The plugin option `settingsSecret`, else `http.cookieSecret` from the
+     * project config (Medusa 2.19.0 always sets it, "supersecret" outside
+     * production when unset).
+     */
+    requireKeyMaterial() {
+        if (this.settingsSecret_) {
+            return this.settingsSecret_;
+        }
+        const cookieSecret = this.cradle_.configModule?.projectConfig?.http?.cookieSecret;
+        if (typeof cookieSecret === "string" && cookieSecret) {
+            return cookieSecret;
+        }
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Für geheime Einstellungen fehlt die Plugin-Option settingsSecret bzw. projectConfig.http.cookieSecret.");
     }
     async retrieveStored(pluginKey, sharedContext) {
         const [row] = await this.listPluginFeatureStates({ plugin_key: pluginKey }, { take: 1 }, sharedContext);
         return row ? toStored(row) : null;
     }
+    async retrieveStoredSettings(pluginKey, sharedContext) {
+        const [row] = await this.listPluginSettingStates({ plugin_key: pluginKey }, { take: 1 }, sharedContext);
+        return row ? toStoredSettings(row) : null;
+    }
 }
 __decorate([
     (0, utils_1.InjectManager)(),
@@ -141,17 +494,66 @@ __decorate([
 ], PluginFeaturesModuleService.prototype, "listEffectiveFeatures", null);
 __decorate([
     (0, utils_1.InjectManager)(),
-    __param(1, (0, utils_1.MedusaContext)()),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PluginFeaturesModuleService.prototype, "describePluginFeatures", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    __param(3, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "updatePluginFeatures", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], PluginFeaturesModuleService.prototype, "updatePluginFeatures", null);
+], PluginFeaturesModuleService.prototype, "describePluginSettings", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "resolvePluginSettings", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(3, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "updatePluginSettings", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "startPluginActionRun", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "finishPluginActionRun", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "reportPluginActionRunProgress", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(3, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "listRecentPluginActionRuns", null);
 exports.default = PluginFeaturesModuleService;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/plugin-features/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/public/action-progress.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_ACTION_PROGRESS_LABEL_MAX_LENGTH = void 0;
+exports.normalizeActionProgress = normalizeActionProgress;
+exports.reportPluginActionProgress = reportPluginActionProgress;
+const utils_1 = require("@medusajs/framework/utils");
+const module_access_1 = require("./module-access");
+/** Longest stored progress label; longer labels are cut. */
+exports.PLUGIN_ACTION_PROGRESS_LABEL_MAX_LENGTH = 200;
+const isCount = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+/**
+ * Validates and normalizes reported progress: `current` and `total` are
+ * non-negative integers (`total` may be unknown), a blank label is `null`
+ * and a long one is cut. Throws `INVALID_DATA`.
+ */
+function normalizeActionProgress(progress) {
+    if (!isCount(progress?.current)) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Fortschritt: current muss eine nicht-negative ganze Zahl sein.");
+    }
+    const total = progress.total ?? null;
+    if (total !== null && !isCount(total)) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Fortschritt: total muss eine nicht-negative ganze Zahl oder null sein.");
+    }
+    const label = typeof progress.label === "string" && progress.label.trim()
+        ? progress.label.trim().slice(0, exports.PLUGIN_ACTION_PROGRESS_LABEL_MAX_LENGTH)
+        : null;
+    return { current: progress.current, total, label };
+}
+const warn = (container, message) => {
+    try {
+        container.resolve(utils_1.ContainerRegistrationKeys.LOGGER).warn(message);
+    }
+    catch {
+        // Progress is informational; logging must not fail the action.
+    }
+};
+/**
+ * Stores the progress of a running action (shown in the Admin while it
+ * runs). Call it from the action's workflow with `input.run_id`. Without a
+ * `run_id` (e.g. the same workflow run from a script) it does nothing. An
+ * unknown or finished run, a failed write and invalid progress (negative
+ * or non-integer numbers) are logged as a warning and dropped; progress
+ * never fails the action.
+ */
+async function reportPluginActionProgress(container, runId, progress) {
+    let normalized;
+    try {
+        normalized = normalizeActionProgress(progress);
+    }
+    catch (error) {
+        warn(container, `Ungültiger Fortschritt${runId ? ` für Aktionslauf "${runId}"` : ""} verworfen: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (!runId) {
+        return;
+    }
+    try {
+        const updated = await (0, module_access_1.resolveBaseModule)(container).reportPluginActionRunProgress(runId, normalized);
+        if (!updated) {
+            warn(container, `Fortschritt für Aktionslauf "${runId}" verworfen: Lauf unbekannt oder nicht mehr aktiv.`);
+        }
+    }
+    catch (error) {
+        warn(container, `Fortschritt für Aktionslauf "${runId}" konnte nicht gespeichert werden: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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