@hartl-services/medusa-base 0.1.0

package/.medusa/server/src/modules/plugin-features/migrations/Migration20260928155256.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20260928155256 = void 0;
+const migrations_1 = require("@medusajs/framework/mikro-orm/migrations");
+class Migration20260928155256 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`create table if not exists "plugin_feature_state" ("id" text not null, "plugin_key" text not null, "enabled" boolean not null, "features" jsonb not null, "version" integer not null default 1, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "plugin_feature_state_pkey" primary key ("id"));`);
+        this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_plugin_feature_state_deleted_at" ON "plugin_feature_state" ("deleted_at") WHERE deleted_at IS NULL;`);
+        this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "IDX_plugin_feature_state_plugin_key" ON "plugin_feature_state" ("plugin_key") WHERE deleted_at IS NULL;`);
+    }
+    async down() {
+        this.addSql(`drop table if exists "plugin_feature_state" cascade;`);
+    }
+}
+exports.Migration20260928155256 = Migration20260928155256;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNjA5MjgxNTUyNTYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wbHVnaW4tZmVhdHVyZXMvbWlncmF0aW9ucy9NaWdyYXRpb24yMDI2MDkyODE1NTI1Ni50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5RUFBcUU7QUFFckUsTUFBYSx1QkFBd0IsU0FBUSxzQkFBUztJQUUzQyxLQUFLLENBQUMsRUFBRTtRQUNmLElBQUksQ0FBQyxNQUFNLENBQUMsOFhBQThYLENBQUMsQ0FBQztRQUM1WSxJQUFJLENBQUMsTUFBTSxDQUFDLHFJQUFxSSxDQUFDLENBQUM7UUFDbkosSUFBSSxDQUFDLE1BQU0sQ0FBQyw0SUFBNEksQ0FBQyxDQUFDO0lBQzVKLENBQUM7SUFFUSxLQUFLLENBQUMsSUFBSTtRQUNqQixJQUFJLENBQUMsTUFBTSxDQUFDLHNEQUFzRCxDQUFDLENBQUM7SUFDdEUsQ0FBQztDQUVGO0FBWkQsMERBWUMifQ==

package/.medusa/server/src/modules/plugin-features/models/plugin-feature-state.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * One row per plugin with configured toggle values. No row means every value
+ * is its declared default.
+ */
+const PluginFeatureState = utils_1.model
+    .define({
+    name: "plugin_feature_state",
+    tableName: "plugin_feature_state",
+}, {
+    id: utils_1.model.id({ prefix: "plgfeat" }).primaryKey(),
+    plugin_key: utils_1.model.text(),
+    enabled: utils_1.model.boolean(),
+    /** Configured values `{ [featureKey]: boolean }`, declared keys only. */
+    features: utils_1.model.json(),
+    version: utils_1.model.number().default(1),
+})
+    .indexes([
+    {
+        name: "IDX_plugin_feature_state_plugin_key",
+        on: ["plugin_key"],
+        unique: true,
+        where: "deleted_at IS NULL",
+    },
+]);
+exports.default = PluginFeatureState;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLWZlYXR1cmUtc3RhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wbHVnaW4tZmVhdHVyZXMvbW9kZWxzL3BsdWdpbi1mZWF0dXJlLXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEscURBQWlEO0FBRWpEOzs7R0FHRztBQUNILE1BQU0sa0JBQWtCLEdBQUcsYUFBSztLQUM3QixNQUFNLENBQ0w7SUFDRSxJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLFNBQVMsRUFBRSxzQkFBc0I7Q0FDbEMsRUFDRDtJQUNFLEVBQUUsRUFBRSxhQUFLLENBQUMsRUFBRSxDQUFDLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUMsVUFBVSxFQUFFO0lBQ2hELFVBQVUsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFO0lBQ3hCLE9BQU8sRUFBRSxhQUFLLENBQUMsT0FBTyxFQUFFO0lBQ3hCLHlFQUF5RTtJQUN6RSxRQUFRLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRTtJQUN0QixPQUFPLEVBQUUsYUFBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7Q0FDbkMsQ0FDRjtLQUNBLE9BQU8sQ0FBQztJQUNQO1FBQ0UsSUFBSSxFQUFFLHFDQUFxQztRQUMzQyxFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUM7UUFDbEIsTUFBTSxFQUFFLElBQUk7UUFDWixLQUFLLEVBQUUsb0JBQW9CO0tBQzVCO0NBQ0YsQ0FBQyxDQUFBO0FBRUosa0JBQWUsa0JBQWtCLENBQUEifQ==

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

@@ -0,0 +1,141 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const effective_features_1 = require("../../public/effective-features");
+const plugin_feature_state_1 = __importDefault(require("./models/plugin-feature-state"));
+const toStored = (row) => {
+    const features = {};
+    if (row.features && typeof row.features === "object") {
+        for (const [key, value] of Object.entries(row.features)) {
+            if (typeof value === "boolean") {
+                features[key] = value;
+            }
+        }
+    }
+    return { enabled: row.enabled, features, version: Number(row.version) };
+};
+const describe = (descriptor, stored) => {
+    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,
+        enabled: states.enabled,
+        version: stored?.version ?? 0,
+        features: states.features.map((state) => ({
+            key: state.definition.key,
+            label: state.definition.label,
+            description: state.definition.description ?? null,
+            parent_key: state.definition.parent_key ?? null,
+            default_enabled: state.definition.default_enabled,
+            enabled: state.enabled,
+            effective_enabled: state.effective_enabled,
+        })),
+    };
+};
+/**
+ * Persists configured toggle values 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,
+}) {
+    async retrieveEffectiveFeatures(descriptor, sharedContext = {}) {
+        const stored = await this.retrieveStored(descriptor.plugin_key, sharedContext);
+        return (0, effective_features_1.resolveEffectivePluginFeatures)(descriptor, stored);
+    }
+    async describePluginFeatures(descriptor, sharedContext = {}) {
+        const stored = await this.retrieveStored(descriptor.plugin_key, sharedContext);
+        return describe(descriptor, stored);
+    }
+    /**
+     * 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 = {}) {
+        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.");
+        }
+        const featuresJson = JSON.stringify(features);
+        const rows = input.expected_version === 0
+            ? await manager.execute(`insert into "plugin_feature_state"
+               ("id", "plugin_key", "enabled", "features", "version",
+                "created_at", "updated_at")
+             values (?, ?, ?, ?::jsonb, 1, now(), now())
+             on conflict do nothing
+             returning "enabled", "features", "version"`, [
+                (0, utils_1.generateEntityId)(undefined, "plgfeat"),
+                descriptor.plugin_key,
+                input.enabled,
+                featuresJson,
+            ], "all")
+            : await manager.execute(`update "plugin_feature_state"
+             set "enabled" = ?,
+                 "features" = ?::jsonb,
+                 "version" = ?,
+                 "updated_at" = now()
+             where "plugin_key" = ?
+               and "version" = ?
+               and "deleted_at" is null
+             returning "enabled", "features", "version"`, [
+                input.enabled,
+                featuresJson,
+                input.expected_version + 1,
+                descriptor.plugin_key,
+                input.expected_version,
+            ], "all");
+        const saved = rows[0];
+        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));
+    }
+    async retrieveStored(pluginKey, sharedContext) {
+        const [row] = await this.listPluginFeatureStates({ plugin_key: pluginKey }, { take: 1 }, sharedContext);
+        return row ? toStored(row) : null;
+    }
+}
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "retrieveEffectiveFeatures", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "describePluginFeatures", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PluginFeaturesModuleService.prototype, "updatePluginFeatures", null);
+exports.default = PluginFeaturesModuleService;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/public/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_FEATURES_MODULE = void 0;
+/** Container key of the base plugin's module (`Module("plugin_features", …)`). */
+exports.PLUGIN_FEATURES_MODULE = "plugin_features";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3B1YmxpYy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsa0ZBQWtGO0FBQ3JFLFFBQUEsc0JBQXNCLEdBQUcsaUJBQTBCLENBQUEifQ==

package/.medusa/server/src/public/descriptor.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePluginFeatureDescriptor = validatePluginFeatureDescriptor;
+exports.definePluginFeatures = definePluginFeatures;
+const utils_1 = require("@medusajs/framework/utils");
+const KEY_PATTERN = /^[a-z][a-z0-9_]{0,62}$/;
+const invalid = (pluginKey, message) => new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Ungültige Funktionsschalter für Plugin "${pluginKey}": ${message}`);
+/**
+ * Checks key format, unique feature keys, existing parents and the single
+ * allowed nesting level. Throws `INVALID_DATA`.
+ */
+function validatePluginFeatureDescriptor(descriptor) {
+    const pluginKey = String(descriptor.plugin_key);
+    if (!KEY_PATTERN.test(pluginKey)) {
+        throw invalid(pluginKey, "plugin_key hat ein ungültiges Format.");
+    }
+    if (typeof descriptor.label !== "string" || !descriptor.label.trim()) {
+        throw invalid(pluginKey, "label fehlt.");
+    }
+    const byKey = new Map();
+    for (const feature of descriptor.features) {
+        if (!KEY_PATTERN.test(feature.key)) {
+            throw invalid(pluginKey, `Feature-Key "${feature.key}" hat ein ungültiges Format.`);
+        }
+        if (byKey.has(feature.key)) {
+            throw invalid(pluginKey, `Feature-Key "${feature.key}" ist doppelt.`);
+        }
+        if (typeof feature.label !== "string" || !feature.label.trim()) {
+            throw invalid(pluginKey, `Feature "${feature.key}" hat kein label.`);
+        }
+        byKey.set(feature.key, feature);
+    }
+    for (const feature of descriptor.features) {
+        if (feature.parent_key === undefined) {
+            continue;
+        }
+        const parent = byKey.get(feature.parent_key);
+        if (!parent || parent.key === feature.key) {
+            throw invalid(pluginKey, `Parent "${feature.parent_key}" von Feature "${feature.key}" existiert nicht.`);
+        }
+        if (parent.parent_key !== undefined) {
+            throw invalid(pluginKey, `Feature "${feature.key}" ist zu tief verschachtelt; erlaubt ist eine Ebene.`);
+        }
+    }
+}
+/**
+ * Declares a plugin's feature switches. Validates at import time so a broken
+ * declaration fails the boot instead of a request.
+ */
+function definePluginFeatures(descriptor) {
+    validatePluginFeatureDescriptor(descriptor);
+    return descriptor;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/public/effective-features.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginFeatureStates = resolvePluginFeatureStates;
+exports.resolveEffectivePluginFeatures = resolveEffectivePluginFeatures;
+exports.validateFeatureUpdate = validateFeatureUpdate;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Configured and effective values of every declared feature.
+ * `effective(f) = pluginEnabled && configured(f) && effective(parent(f))`.
+ * Stored keys the descriptor no longer declares are ignored; declared keys
+ * without a stored value fall back to their default.
+ */
+function resolvePluginFeatureStates(descriptor, stored) {
+    const pluginEnabled = stored
+        ? stored.enabled
+        : descriptor.default_enabled ?? true;
+    const configured = new Map();
+    for (const feature of descriptor.features) {
+        const value = stored?.features[feature.key];
+        configured.set(feature.key, typeof value === "boolean" ? value : feature.default_enabled);
+    }
+    const effective = (feature) => {
+        if (!pluginEnabled || configured.get(feature.key) !== true) {
+            return false;
+        }
+        if (feature.parent_key === undefined) {
+            return true;
+        }
+        // Validated descriptors allow one nesting level, so the parent is a root.
+        return configured.get(feature.parent_key) === true;
+    };
+    return {
+        enabled: pluginEnabled,
+        features: descriptor.features.map((definition) => ({
+            definition,
+            enabled: configured.get(definition.key) === true,
+            effective_enabled: effective(definition),
+        })),
+    };
+}
+/** Pure rule shared by service and tests. `stored === null` means no row. */
+function resolveEffectivePluginFeatures(descriptor, stored) {
+    const states = resolvePluginFeatureStates(descriptor, stored);
+    const features = {};
+    for (const state of states.features) {
+        features[state.definition.key] = state.effective_enabled;
+    }
+    return {
+        plugin_key: descriptor.plugin_key,
+        enabled: states.enabled,
+        features,
+    };
+}
+/**
+ * Rejects configured values for keys the descriptor does not declare and
+ * returns the values to persist (declared keys only; missing keys keep their
+ * default).
+ */
+function validateFeatureUpdate(descriptor, features) {
+    const declared = new Set(descriptor.features.map((feature) => feature.key));
+    const unknown = Object.keys(features).filter((key) => !declared.has(key));
+    if (unknown.length) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Unbekannte Funktionsschalter für Plugin "${descriptor.plugin_key}": ${unknown.join(", ")}.`);
+    }
+    const result = {};
+    for (const feature of descriptor.features) {
+        const value = features[feature.key];
+        if (typeof value === "boolean") {
+            result[feature.key] = value;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/public/enforcement.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPluginFeatureEnabled = isPluginFeatureEnabled;
+exports.requirePluginFeature = requirePluginFeature;
+const utils_1 = require("@medusajs/framework/utils");
+const constants_1 = require("./constants");
+const resolveReader = (container) => {
+    if (!container.hasRegistration(constants_1.PLUGIN_FEATURES_MODULE)) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "@hartl-services/medusa-base ist nicht in medusa-config registriert.");
+    }
+    return container.resolve(constants_1.PLUGIN_FEATURES_MODULE);
+};
+const allEnabled = (effective, keys) => effective.enabled && keys.every((key) => effective.features[key] === true);
+/**
+ * For subscribers, jobs and workflow steps. No keys = plugin switch only;
+ * several keys = all must be enabled. Read failures propagate.
+ */
+async function isPluginFeatureEnabled(container, descriptor, ...keys) {
+    const effective = await resolveReader(container).retrieveEffectiveFeatures(descriptor);
+    return allEnabled(effective, keys);
+}
+// Keyed by the request object, so one request reads each plugin's toggles once
+// even when several gate middlewares match it.
+const requestMemo = new WeakMap();
+const effectiveForRequest = (req, descriptor) => {
+    let perRequest = requestMemo.get(req);
+    if (!perRequest) {
+        perRequest = new Map();
+        requestMemo.set(req, perRequest);
+    }
+    let pending = perRequest.get(descriptor.plugin_key);
+    if (!pending) {
+        pending = resolveReader(req.scope).retrieveEffectiveFeatures(descriptor);
+        perRequest.set(descriptor.plugin_key, pending);
+    }
+    return pending;
+};
+/**
+ * Middleware for `defineMiddlewares`. A disabled plugin or feature answers
+ * with `NOT_FOUND` (404); all given keys must be enabled.
+ */
+function requirePluginFeature(descriptor, ...keys) {
+    return async (req, _res, next) => {
+        const effective = await effectiveForRequest(req, descriptor);
+        if (!allEnabled(effective, keys)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Diese Funktion ist in diesem Shop nicht aktiviert.");
+        }
+        next();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requirePluginFeature = exports.isPluginFeatureEnabled = exports.resolveEffectivePluginFeatures = exports.definePluginFeatures = exports.PLUGIN_FEATURES_MODULE = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "PLUGIN_FEATURES_MODULE", { enumerable: true, get: function () { return constants_1.PLUGIN_FEATURES_MODULE; } });
+var descriptor_1 = require("./descriptor");
+Object.defineProperty(exports, "definePluginFeatures", { enumerable: true, get: function () { return descriptor_1.definePluginFeatures; } });
+var effective_features_1 = require("./effective-features");
+Object.defineProperty(exports, "resolveEffectivePluginFeatures", { enumerable: true, get: function () { return effective_features_1.resolveEffectivePluginFeatures; } });
+var enforcement_1 = require("./enforcement");
+Object.defineProperty(exports, "isPluginFeatureEnabled", { enumerable: true, get: function () { return enforcement_1.isPluginFeatureEnabled; } });
+Object.defineProperty(exports, "requirePluginFeature", { enumerable: true, get: function () { return enforcement_1.requirePluginFeature; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHVibGljL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHlDQUFvRDtBQUEzQyxtSEFBQSxzQkFBc0IsT0FBQTtBQUMvQiwyQ0FBbUQ7QUFBMUMsa0hBQUEsb0JBQW9CLE9BQUE7QUFDN0IsMkRBQXFFO0FBQTVELG9JQUFBLDhCQUE4QixPQUFBO0FBQ3ZDLDZDQUE0RTtBQUFuRSxxSEFBQSxzQkFBc0IsT0FBQTtBQUFFLG1IQUFBLG9CQUFvQixPQUFBIn0=

package/.medusa/server/src/public/types.js

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

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverPluginFeatureDescriptors = discoverPluginFeatureDescriptors;
+exports.findPluginFeatureDescriptor = findPluginFeatureDescriptor;
+const utils_1 = require("@medusajs/framework/utils");
+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 readDescriptor = (service) => service !== null && typeof service === "object" && "pluginFeatures" in service
+    ? service.pluginFeatures
+    : undefined;
+/**
+ * Finds every registered module whose service declares `pluginFeatures`.
+ * Fails closed: an invalid or duplicate declaration is `UNEXPECTED_STATE`.
+ */
+function discoverPluginFeatureDescriptors(container) {
+    const configModule = container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+    const memo = discovered.get(configModule);
+    if (memo) {
+        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));
+        if (candidate === undefined) {
+            continue;
+        }
+        const descriptor = candidate;
+        try {
+            (0, descriptor_1.validatePluginFeatureDescriptor)(descriptor);
+        }
+        catch (error) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Modul "${moduleKey}" deklariert ungültige Funktionsschalter: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (byPluginKey.has(descriptor.plugin_key)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Plugin-Key "${descriptor.plugin_key}" wird von mehreren Modulen deklariert.`);
+        }
+        byPluginKey.set(descriptor.plugin_key, descriptor);
+    }
+    const result = [...byPluginKey.values()].sort((left, right) => left.plugin_key.localeCompare(right.plugin_key));
+    discovered.set(configModule, result);
+    return result;
+}
+function findPluginFeatureDescriptor(container, pluginKey) {
+    return discoverPluginFeatureDescriptors(container).find((descriptor) => descriptor.plugin_key === pluginKey);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzY292ZXItcGx1Z2luLWZlYXR1cmVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL2Rpc2NvdmVyLXBsdWdpbi1mZWF0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQXVCQSw0RUFnREM7QUFFRCxrRUFPQztBQS9FRCxxREFBa0Y7QUFFbEYscURBQXNFO0FBT3RFLDRFQUE0RTtBQUM1RSxpREFBaUQ7QUFDakQsTUFBTSxVQUFVLEdBQUcsSUFBSSxPQUFPLEVBQXFDLENBQUE7QUFFbkUsTUFBTSxjQUFjLEdBQUcsQ0FBQyxPQUFnQixFQUFXLEVBQUUsQ0FDbkQsT0FBTyxLQUFLLElBQUksSUFBSSxPQUFPLE9BQU8sS0FBSyxRQUFRLElBQUksZ0JBQWdCLElBQUksT0FBTztJQUM1RSxDQUFDLENBQUUsT0FBdUMsQ0FBQyxjQUFjO0lBQ3pELENBQUMsQ0FBQyxTQUFTLENBQUE7QUFFZjs7O0dBR0c7QUFDSCxTQUFnQixnQ0FBZ0MsQ0FDOUMsU0FBMEI7SUFFMUIsTUFBTSxZQUFZLEdBQUcsU0FBUyxDQUFDLE9BQU8sQ0FDcEMsaUNBQXlCLENBQUMsYUFBYSxDQUN4QyxDQUFBO0lBQ0QsTUFBTSxJQUFJLEdBQUcsVUFBVSxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQTtJQUN6QyxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ1QsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDO0lBRUQsTUFBTSxXQUFXLEdBQUcsSUFBSSxHQUFHLEVBQW1DLENBQUE7SUFDOUQsS0FBSyxNQUFNLFNBQVMsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDLEVBQUUsQ0FBQztRQUNoRSxJQUFJLENBQUMsU0FBUyxDQUFDLGVBQWUsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDO1lBQzFDLFNBQVE7UUFDVixDQUFDO1FBRUQsTUFBTSxTQUFTLEdBQUcsY0FBYyxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQVUsU0FBUyxDQUFDLENBQUMsQ0FBQTtRQUN2RSxJQUFJLFNBQVMsS0FBSyxTQUFTLEVBQUUsQ0FBQztZQUM1QixTQUFRO1FBQ1YsQ0FBQztRQUVELE1BQU0sVUFBVSxHQUFHLFNBQW9DLENBQUE7UUFDdkQsSUFBSSxDQUFDO1lBQ0gsSUFBQSw0Q0FBK0IsRUFBQyxVQUFVLENBQUMsQ0FBQTtRQUM3QyxDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNmLE1BQU0sSUFBSSxtQkFBVyxDQUNuQixtQkFBVyxDQUFDLEtBQUssQ0FBQyxnQkFBZ0IsRUFDbEMsVUFBVSxTQUFTLDZDQUNqQixLQUFLLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUN2RCxFQUFFLENBQ0gsQ0FBQTtRQUNILENBQUM7UUFFRCxJQUFJLFdBQVcsQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7WUFDM0MsTUFBTSxJQUFJLG1CQUFXLENBQ25CLG1CQUFXLENBQUMsS0FBSyxDQUFDLGdCQUFnQixFQUNsQyxlQUFlLFVBQVUsQ0FBQyxVQUFVLHlDQUF5QyxDQUM5RSxDQUFBO1FBQ0gsQ0FBQztRQUNELFdBQVcsQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQTtJQUNwRCxDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQUcsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUM1RCxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQ2hELENBQUE7SUFDRCxVQUFVLENBQUMsR0FBRyxDQUFDLFlBQVksRUFBRSxNQUFNLENBQUMsQ0FBQTtJQUNwQyxPQUFPLE1BQU0sQ0FBQTtBQUNmLENBQUM7QUFFRCxTQUFnQiwyQkFBMkIsQ0FDekMsU0FBMEIsRUFDMUIsU0FBaUI7SUFFakIsT0FBTyxnQ0FBZ0MsQ0FBQyxTQUFTLENBQUMsQ0FBQyxJQUFJLENBQ3JELENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsVUFBVSxLQUFLLFNBQVMsQ0FDcEQsQ0FBQTtBQUNILENBQUMifQ==

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hartl Services GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.