@hartl-services/medusa-base 0.3.0 → 1.0.0

package/dist/public/descriptor.js

@@ -4,10 +4,190 @@ exports.validatePluginFeatureDescriptor = validatePluginFeatureDescriptor;
 exports.definePluginFeatures = definePluginFeatures;
 const utils_1 = require("@medusajs/framework/utils");
 const KEY_PATTERN = /^[a-z][a-z0-9_]{0,62}$/;
+const SETTING_TYPES = new Set([
+    "string",
+    "url",
+    "number",
+    "boolean",
+    "secret",
+    "select",
+]);
+const ACTION_MODES = new Set(["sync", "background"]);
+const ADMIN_PAGE_PREFIX = "/settings/hartl-services/";
+const BASE_PAGE_PREFIX = "/settings/hartl-services/plugin/";
+const ADMIN_PAGE_PATTERN = /^\/settings\/hartl-services(\/[a-z0-9][a-z0-9_-]*)+$/;
+const isHttpUrl = (value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+};
 const invalid = (pluginKey, message) => new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Ungültige Funktionsschalter für Plugin "${pluginKey}": ${message}`);
+const hasText = (value) => typeof value === "string" && value.trim().length > 0;
+const defaultMatchesType = (setting) => {
+    const value = setting.default;
+    switch (setting.type) {
+        case "string":
+            return hasText(value);
+        case "url":
+            return typeof value === "string" && isHttpUrl(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "select":
+            return (typeof value === "string" &&
+                (setting.options ?? []).some((option) => option.value === value));
+        default:
+            return false;
+    }
+};
+const withinBounds = (setting) => typeof setting.default !== "number" ||
+    ((setting.min === undefined || setting.default >= setting.min) &&
+        (setting.max === undefined || setting.default <= setting.max));
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+/** `options` only (and required) for select, `min`/`max` only for number. */
+const validateTypeExtras = (pluginKey, setting) => {
+    if (setting.type === "select") {
+        const options = setting.options;
+        if (!Array.isArray(options) || options.length === 0) {
+            throw invalid(pluginKey, `Auswahl "${setting.key}" braucht mindestens eine Option.`);
+        }
+        const values = new Set();
+        for (const option of options) {
+            if (!hasText(option?.value) || !hasText(option?.label)) {
+                throw invalid(pluginKey, `Auswahl "${setting.key}" hat eine Option ohne value oder label.`);
+            }
+            if (values.has(option.value)) {
+                throw invalid(pluginKey, `Auswahl "${setting.key}" hat die Option "${option.value}" doppelt.`);
+            }
+            values.add(option.value);
+        }
+    }
+    else if (setting.options !== undefined) {
+        throw invalid(pluginKey, `Einstellung "${setting.key}": options gibt es nur bei "select".`);
+    }
+    if (setting.type !== "number") {
+        if (setting.min !== undefined || setting.max !== undefined) {
+            throw invalid(pluginKey, `Einstellung "${setting.key}": min/max gibt es nur bei "number".`);
+        }
+        return;
+    }
+    for (const [name, bound] of [
+        ["min", setting.min],
+        ["max", setting.max],
+    ]) {
+        if (bound !== undefined && !isFiniteNumber(bound)) {
+            throw invalid(pluginKey, `Einstellung "${setting.key}": ${name} muss eine endliche Zahl sein.`);
+        }
+    }
+    if (setting.min !== undefined &&
+        setting.max !== undefined &&
+        setting.min > setting.max) {
+        throw invalid(pluginKey, `Einstellung "${setting.key}": min ist größer als max.`);
+    }
+};
+/**
+ * `invalidates` lists secrets of the same plugin that a change of this
+ * setting deletes (e.g. an API key that must not go to a new URL).
+ */
+const validateInvalidates = (pluginKey, setting, settings) => {
+    const invalidates = setting.invalidates;
+    if (invalidates === undefined) {
+        return;
+    }
+    if (!Array.isArray(invalidates) || invalidates.length === 0) {
+        throw invalid(pluginKey, `Einstellung "${setting.key}": invalidates muss eine nicht-leere Liste sein.`);
+    }
+    const seen = new Set();
+    for (const key of invalidates) {
+        const target = settings.find((candidate) => candidate.key === key);
+        if (typeof key !== "string" || !target || target.type !== "secret") {
+            throw invalid(pluginKey, `Einstellung "${setting.key}": invalidates nennt "${String(key)}", das keine geheime Einstellung dieses Plugins ist.`);
+        }
+        if (key === setting.key || seen.has(key)) {
+            throw invalid(pluginKey, `Einstellung "${setting.key}": invalidates nennt "${key}" doppelt oder sich selbst.`);
+        }
+        seen.add(key);
+    }
+};
+const validateSettings = (pluginKey, settings) => {
+    const seen = new Set();
+    for (const setting of settings) {
+        if (!KEY_PATTERN.test(setting.key)) {
+            throw invalid(pluginKey, `Einstellungs-Key "${setting.key}" hat ein ungültiges Format.`);
+        }
+        if (seen.has(setting.key)) {
+            throw invalid(pluginKey, `Einstellungs-Key "${setting.key}" ist doppelt.`);
+        }
+        seen.add(setting.key);
+        if (!hasText(setting.label)) {
+            throw invalid(pluginKey, `Einstellung "${setting.key}" hat kein label.`);
+        }
+        if (!SETTING_TYPES.has(setting.type)) {
+            throw invalid(pluginKey, `Einstellung "${setting.key}" hat einen unbekannten Typ.`);
+        }
+        if (setting.required !== undefined && typeof setting.required !== "boolean") {
+            throw invalid(pluginKey, `Einstellung "${setting.key}": required muss boolean sein.`);
+        }
+        validateTypeExtras(pluginKey, setting);
+        validateInvalidates(pluginKey, setting, settings);
+        if (setting.default === undefined) {
+            continue;
+        }
+        if (setting.type === "secret") {
+            throw invalid(pluginKey, `Geheime Einstellung "${setting.key}" darf keinen Standardwert haben.`);
+        }
+        if (!defaultMatchesType(setting)) {
+            throw invalid(pluginKey, `Standardwert von Einstellung "${setting.key}" passt nicht zum Typ "${setting.type}".`);
+        }
+        if (!withinBounds(setting)) {
+            throw invalid(pluginKey, `Standardwert von Einstellung "${setting.key}" liegt außerhalb von min/max.`);
+        }
+    }
+};
+const validateActions = (pluginKey, actions) => {
+    const seen = new Set();
+    for (const action of actions) {
+        if (!KEY_PATTERN.test(action.key)) {
+            throw invalid(pluginKey, `Aktions-Key "${action.key}" hat ein ungültiges Format.`);
+        }
+        if (seen.has(action.key)) {
+            throw invalid(pluginKey, `Aktions-Key "${action.key}" ist doppelt.`);
+        }
+        seen.add(action.key);
+        if (!hasText(action.label)) {
+            throw invalid(pluginKey, `Aktion "${action.key}" hat kein label.`);
+        }
+        if (!hasText(action.workflow_id)) {
+            throw invalid(pluginKey, `Aktion "${action.key}" hat keine workflow_id.`);
+        }
+        if (!ACTION_MODES.has(action.mode)) {
+            throw invalid(pluginKey, `Aktion "${action.key}" hat einen unbekannten Modus.`);
+        }
+        if (action.confirm !== undefined && !hasText(action.confirm)) {
+            throw invalid(pluginKey, `Aktion "${action.key}": confirm ist leer.`);
+        }
+    }
+};
+const validateAdminPage = (pluginKey, path) => {
+    if (path === undefined) {
+        return;
+    }
+    if (typeof path !== "string" ||
+        !path.startsWith(ADMIN_PAGE_PREFIX) ||
+        path.startsWith(BASE_PAGE_PREFIX) ||
+        !ADMIN_PAGE_PATTERN.test(path)) {
+        throw invalid(pluginKey, `admin_page "${String(path)}" muss unter "${ADMIN_PAGE_PREFIX}<plugin>" liegen und darf nicht mit "${BASE_PAGE_PREFIX}" beginnen.`);
+    }
+};
 /**
  * Checks key format, unique feature keys, existing parents and the single
- * allowed nesting level. Throws `INVALID_DATA`.
+ * allowed nesting level, plus the optional settings, actions and Admin page.
+ * Throws `INVALID_DATA`.
  */
 function validatePluginFeatureDescriptor(descriptor) {
     const pluginKey = String(descriptor.plugin_key);
@@ -17,6 +197,17 @@ function validatePluginFeatureDescriptor(descriptor) {
     if (typeof descriptor.label !== "string" || !descriptor.label.trim()) {
         throw invalid(pluginKey, "label fehlt.");
     }
+    if (descriptor.switchable !== undefined &&
+        typeof descriptor.switchable !== "boolean") {
+        throw invalid(pluginKey, "switchable muss boolean sein.");
+    }
+    if (descriptor.default_enabled !== undefined &&
+        typeof descriptor.default_enabled !== "boolean") {
+        throw invalid(pluginKey, "default_enabled muss boolean sein.");
+    }
+    if (descriptor.switchable === false && descriptor.default_enabled === false) {
+        throw invalid(pluginKey, "Ein nicht abschaltbares Plugin (switchable: false) kann nicht default_enabled: false haben.");
+    }
     const byKey = new Map();
     for (const feature of descriptor.features) {
         if (!KEY_PATTERN.test(feature.key)) {
@@ -28,6 +219,9 @@ function validatePluginFeatureDescriptor(descriptor) {
         if (typeof feature.label !== "string" || !feature.label.trim()) {
             throw invalid(pluginKey, `Feature "${feature.key}" hat kein label.`);
         }
+        if (typeof feature.default_enabled !== "boolean") {
+            throw invalid(pluginKey, `Feature "${feature.key}": default_enabled muss boolean sein.`);
+        }
         byKey.set(feature.key, feature);
     }
     for (const feature of descriptor.features) {
@@ -42,6 +236,9 @@ function validatePluginFeatureDescriptor(descriptor) {
             throw invalid(pluginKey, `Feature "${feature.key}" ist zu tief verschachtelt; erlaubt ist eine Ebene.`);
         }
     }
+    validateSettings(pluginKey, descriptor.settings ?? []);
+    validateActions(pluginKey, descriptor.actions ?? []);
+    validateAdminPage(pluginKey, descriptor.admin_page);
 }
 /**
  * Declares a plugin's feature switches. Validates at import time so a broken

package/dist/public/effective-features.d.ts

@@ -12,7 +12,8 @@ export type PluginFeatureStates = {
     features: PluginFeatureState[];
 };
 /**
- * Configured and effective values of every declared feature.
+ * Configured and effective values of every declared feature. A descriptor
+ * with `switchable: false` is always enabled.
  * `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.

package/dist/public/effective-features.js

@@ -5,15 +5,19 @@ exports.resolveEffectivePluginFeatures = resolveEffectivePluginFeatures;
 exports.validateFeatureUpdate = validateFeatureUpdate;
 const utils_1 = require("@medusajs/framework/utils");
 /**
- * Configured and effective values of every declared feature.
+ * Configured and effective values of every declared feature. A descriptor
+ * with `switchable: false` is always enabled.
  * `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;
+    // A plugin that cannot be switched off is always on, whatever is stored.
+    const pluginEnabled = descriptor.switchable === false
+        ? true
+        : stored
+            ? stored.enabled
+            : descriptor.default_enabled ?? true;
     const configured = new Map();
     for (const feature of descriptor.features) {
         const value = stored?.features[feature.key];

package/dist/public/enforcement.d.ts

@@ -6,6 +6,13 @@ import type { PluginFeatureDescriptor } from "./types";
  * several keys = all must be enabled. Read failures propagate.
  */
 export declare function isPluginFeatureEnabled<K extends string>(container: MedusaContainer, descriptor: PluginFeatureDescriptor<K>, ...keys: K[]): Promise<boolean>;
+/**
+ * Like `isPluginFeatureEnabled`, for another plugin known only by its key
+ * (no import of that plugin): finds its descriptor among the registered
+ * modules. An unknown or uninstalled plugin key is `false`, as is an
+ * undeclared feature key. Read failures propagate.
+ */
+export declare function isPluginFeatureEnabledByKey(container: MedusaContainer, pluginKey: string, ...featureKeys: string[]): Promise<boolean>;
 /**
  * Middleware for `defineMiddlewares`. A disabled plugin or feature answers
  * with `NOT_FOUND` (404); all given keys must be enabled.

package/dist/public/enforcement.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPluginFeatureEnabled = isPluginFeatureEnabled;
+exports.isPluginFeatureEnabledByKey = isPluginFeatureEnabledByKey;
 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 discover_plugin_features_1 = require("../utils/discover-plugin-features");
+const module_access_1 = require("./module-access");
+const resolveReader = (container) => (0, module_access_1.resolveBaseModule)(container);
 const allEnabled = (effective, keys) => effective.enabled && keys.every((key) => effective.features[key] === true);
 /**
  * For subscribers, jobs and workflow steps. No keys = plugin switch only;
@@ -19,6 +16,19 @@ async function isPluginFeatureEnabled(container, descriptor, ...keys) {
     const effective = await resolveReader(container).retrieveEffectiveFeatures(descriptor);
     return allEnabled(effective, keys);
 }
+/**
+ * Like `isPluginFeatureEnabled`, for another plugin known only by its key
+ * (no import of that plugin): finds its descriptor among the registered
+ * modules. An unknown or uninstalled plugin key is `false`, as is an
+ * undeclared feature key. Read failures propagate.
+ */
+async function isPluginFeatureEnabledByKey(container, pluginKey, ...featureKeys) {
+    const descriptor = (0, discover_plugin_features_1.findPluginFeatureDescriptor)(container, pluginKey);
+    if (!descriptor) {
+        return false;
+    }
+    return isPluginFeatureEnabled(container, descriptor, ...featureKeys);
+}
 // 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();

package/dist/public/gateway.d.ts

@@ -0,0 +1,2 @@
+/** Entry of `@hartl-services/medusa-base/gateway`: `/files` signing helpers. */
+export * from "../files/gateway";

package/dist/public/gateway.js

@@ -0,0 +1,18 @@
+"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 __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 });
+/** Entry of `@hartl-services/medusa-base/gateway`: `/files` signing helpers. */
+__exportStar(require("../files/gateway"), exports);

package/dist/public/index.d.ts

@@ -1,6 +1,9 @@
 export { PLUGIN_FEATURES_MODULE } from "./constants";
 export { definePluginFeatures } from "./descriptor";
 export { resolveEffectivePluginFeatures } from "./effective-features";
-export { isPluginFeatureEnabled, requirePluginFeature } from "./enforcement";
-export type { EffectivePluginFeatures, PluginFeatureDefinition, PluginFeatureDescriptor, PluginFeatureProvider, } from "./types";
+export { isPluginFeatureEnabled, isPluginFeatureEnabledByKey, requirePluginFeature, } from "./enforcement";
+export { getPluginSettings } from "./settings";
+export { getShopMasterData, shopMasterDataDescriptor, type ResolvedShopMasterData, type ShopMasterData, type ShopMasterDataKey, } from "./shop-master-data";
+export { reportPluginActionProgress, type PluginActionProgress, } from "./action-progress";
+export type { BasePluginOptions, EffectivePluginFeatures, PluginActionDefinition, PluginActionMode, PluginActionProgressInput, PluginActionWorkflowInput, PluginFeatureDefinition, PluginFeatureDescriptor, PluginFeatureProvider, PluginSettingDefinition, PluginSettingOption, PluginSettingsFallback, PluginSettingType, PluginSettingValue, ResolvedPluginSettings, } from "./types";
 export type { CompleteCartHookDeclarations, CompleteCartHookName, CompleteCartOrderCreatedInput, CompleteCartParticipant, CompleteCartParticipantStep, CompleteCartValidateInput, } from "./complete-cart";

package/dist/public/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requirePluginFeature = exports.isPluginFeatureEnabled = exports.resolveEffectivePluginFeatures = exports.definePluginFeatures = exports.PLUGIN_FEATURES_MODULE = void 0;
+exports.reportPluginActionProgress = exports.shopMasterDataDescriptor = exports.getShopMasterData = exports.getPluginSettings = exports.requirePluginFeature = exports.isPluginFeatureEnabledByKey = 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");
@@ -9,4 +9,12 @@ 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, "isPluginFeatureEnabledByKey", { enumerable: true, get: function () { return enforcement_1.isPluginFeatureEnabledByKey; } });
 Object.defineProperty(exports, "requirePluginFeature", { enumerable: true, get: function () { return enforcement_1.requirePluginFeature; } });
+var settings_1 = require("./settings");
+Object.defineProperty(exports, "getPluginSettings", { enumerable: true, get: function () { return settings_1.getPluginSettings; } });
+var shop_master_data_1 = require("./shop-master-data");
+Object.defineProperty(exports, "getShopMasterData", { enumerable: true, get: function () { return shop_master_data_1.getShopMasterData; } });
+Object.defineProperty(exports, "shopMasterDataDescriptor", { enumerable: true, get: function () { return shop_master_data_1.shopMasterDataDescriptor; } });
+var action_progress_1 = require("./action-progress");
+Object.defineProperty(exports, "reportPluginActionProgress", { enumerable: true, get: function () { return action_progress_1.reportPluginActionProgress; } });

package/dist/public/instrumentation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Medusa's start command only calls a function named exactly `register` from
+ * the shop's `instrumentation.ts` (see @medusajs/medusa/dist/commands/start.js),
+ * so the shop re-exports it:
+ *
+ *   export { register } from "@hartl-services/medusa-base/instrumentation"
+ *
+ * SENTRY_DSN is optional: unset means "no error tracking", not "the app
+ * won't start". Needs `@sentry/node` (optional peer dependency of the base,
+ * installed by the shop).
+ */
+export declare function register(): void;

package/dist/public/instrumentation.js

@@ -0,0 +1,55 @@
+"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.register = register;
+const Sentry = __importStar(require("@sentry/node"));
+/**
+ * Medusa's start command only calls a function named exactly `register` from
+ * the shop's `instrumentation.ts` (see @medusajs/medusa/dist/commands/start.js),
+ * so the shop re-exports it:
+ *
+ *   export { register } from "@hartl-services/medusa-base/instrumentation"
+ *
+ * SENTRY_DSN is optional: unset means "no error tracking", not "the app
+ * won't start". Needs `@sentry/node` (optional peer dependency of the base,
+ * installed by the shop).
+ */
+function register() {
+    Sentry.init({
+        dsn: process.env.SENTRY_DSN,
+        environment: process.env.SENTRY_ENVIRONMENT || process.env.NODE_ENV,
+        tracesSampleRate: 0,
+    });
+}

package/dist/public/module-access.d.ts

@@ -0,0 +1,3 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+/** Resolves the base module or fails with a clear `UNEXPECTED_STATE`. */
+export declare const resolveBaseModule: <T>(container: MedusaContainer) => T;

package/dist/public/module-access.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBaseModule = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const constants_1 = require("./constants");
+/** Resolves the base module or fails with a clear `UNEXPECTED_STATE`. */
+const resolveBaseModule = (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);
+};
+exports.resolveBaseModule = resolveBaseModule;

package/dist/public/settings.d.ts

@@ -0,0 +1,11 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+import type { PluginFeatureDescriptor, PluginSettingsFallback, ResolvedPluginSettings } from "./types";
+/**
+ * Current settings of a plugin for server-side code (subscribers, workflow
+ * steps, jobs, scripts, module services via the global container). Secrets
+ * are DECRYPTED; never send the result to a client. Precedence per key:
+ * stored in the Admin > `fallback` (medusa-config) > declared default.
+ * A missing base plugin fails with `UNEXPECTED_STATE`; read failures
+ * propagate.
+ */
+export declare function getPluginSettings<K extends string, S extends string, A extends string>(container: MedusaContainer, descriptor: PluginFeatureDescriptor<K, S, A>, fallback?: PluginSettingsFallback<S>): Promise<ResolvedPluginSettings<S>>;

package/dist/public/settings.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginSettings = getPluginSettings;
+const module_access_1 = require("./module-access");
+/**
+ * Current settings of a plugin for server-side code (subscribers, workflow
+ * steps, jobs, scripts, module services via the global container). Secrets
+ * are DECRYPTED; never send the result to a client. Precedence per key:
+ * stored in the Admin > `fallback` (medusa-config) > declared default.
+ * A missing base plugin fails with `UNEXPECTED_STATE`; read failures
+ * propagate.
+ */
+async function getPluginSettings(container, descriptor, fallback) {
+    const resolved = await (0, module_access_1.resolveBaseModule)(container).resolvePluginSettings(descriptor, fallback);
+    return resolved;
+}

package/dist/public/shop-config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Entry of `@hartl-services/medusa-base/shop-config`: the turnkey
+ * `medusa-config.ts` of a food shop. Separate from `./config` because it loads
+ * the Sentry logger wrapper and with it `@sentry/node`.
+ */
+export { buildFoodShopConfig, defineFoodShopConfig, } from "../shop-config/build-food-shop-config";
+export type { FoodShopConfigInput, FoodShopModule, FoodShopPlugin, } from "../shop-config/build-food-shop-config";
+export type { FoodShopConfigOptions } from "../shop-config/options";

package/dist/public/shop-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineFoodShopConfig = exports.buildFoodShopConfig = void 0;
+/**
+ * Entry of `@hartl-services/medusa-base/shop-config`: the turnkey
+ * `medusa-config.ts` of a food shop. Separate from `./config` because it loads
+ * the Sentry logger wrapper and with it `@sentry/node`.
+ */
+var build_food_shop_config_1 = require("../shop-config/build-food-shop-config");
+Object.defineProperty(exports, "buildFoodShopConfig", { enumerable: true, get: function () { return build_food_shop_config_1.buildFoodShopConfig; } });
+Object.defineProperty(exports, "defineFoodShopConfig", { enumerable: true, get: function () { return build_food_shop_config_1.defineFoodShopConfig; } });

package/dist/public/shop-master-data.d.ts

@@ -0,0 +1,25 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+import type { PluginSettingsFallback } from "./types";
+/**
+ * The base's own descriptor: the shop's master data (Firmenangaben), edited
+ * on the generic plugin page like any plugin's settings. It cannot be
+ * switched off and declares no features.
+ */
+export declare const shopMasterDataDescriptor: import("./types").PluginFeatureDescriptor<string, "legal_name" | "address_line1" | "address_line2" | "postal_code" | "city" | "country_code" | "vat_number" | "email" | "phone" | "website" | "iban" | "bic" | "company_register_number" | "company_register_court", never>;
+/** Keys of the shop master data settings. */
+export type ShopMasterDataKey = "legal_name" | "address_line1" | "address_line2" | "postal_code" | "city" | "country_code" | "vat_number" | "email" | "phone" | "website" | "iban" | "bic" | "company_register_number" | "company_register_court";
+/** Every key that has a value (stored > fallback). All values are strings. */
+export type ShopMasterData = Partial<Record<ShopMasterDataKey, string>>;
+export type ResolvedShopMasterData = {
+    values: ShopMasterData;
+    /** Every required field has a value. */
+    configured: boolean;
+    /** Required keys without a value. */
+    missing: ShopMasterDataKey[];
+};
+/**
+ * The shop's master data for server-side code. Precedence per key: stored in
+ * the Admin > `fallback` (e.g. a plugin's own medusa-config option). A
+ * missing base plugin fails with `UNEXPECTED_STATE`; read failures propagate.
+ */
+export declare function getShopMasterData(container: MedusaContainer, fallback?: PluginSettingsFallback<ShopMasterDataKey>): Promise<ResolvedShopMasterData>;

package/dist/public/shop-master-data.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shopMasterDataDescriptor = void 0;
+exports.getShopMasterData = getShopMasterData;
+const descriptor_1 = require("./descriptor");
+const settings_1 = require("./settings");
+/**
+ * The base's own descriptor: the shop's master data (Firmenangaben), edited
+ * on the generic plugin page like any plugin's settings. It cannot be
+ * switched off and declares no features.
+ */
+exports.shopMasterDataDescriptor = (0, descriptor_1.definePluginFeatures)({
+    plugin_key: "shop",
+    label: "Shop-Stammdaten",
+    description: "Firmenangaben des Shops für Rechnungen, Dokumente und Steuerprüfungen.",
+    switchable: false,
+    features: [],
+    settings: [
+        { key: "legal_name", label: "Firmenname", type: "string", required: true },
+        { key: "address_line1", label: "Adresse", type: "string", required: true },
+        { key: "address_line2", label: "Adresszusatz", type: "string" },
+        { key: "postal_code", label: "Postleitzahl", type: "string", required: true },
+        { key: "city", label: "Ort", type: "string", required: true },
+        {
+            key: "country_code",
+            label: "Land",
+            type: "select",
+            required: true,
+            // EU-27 plus CH, GB, NO, IS, LI (ISO 3166-1 alpha-2, lowercase),
+            // sorted by German label.
+            options: [
+                { value: "be", label: "Belgien" },
+                { value: "bg", label: "Bulgarien" },
+                { value: "dk", label: "Dänemark" },
+                { value: "de", label: "Deutschland" },
+                { value: "ee", label: "Estland" },
+                { value: "fi", label: "Finnland" },
+                { value: "fr", label: "Frankreich" },
+                { value: "gr", label: "Griechenland" },
+                { value: "ie", label: "Irland" },
+                { value: "is", label: "Island" },
+                { value: "it", label: "Italien" },
+                { value: "hr", label: "Kroatien" },
+                { value: "lv", label: "Lettland" },
+                { value: "li", label: "Liechtenstein" },
+                { value: "lt", label: "Litauen" },
+                { value: "lu", label: "Luxemburg" },
+                { value: "mt", label: "Malta" },
+                { value: "nl", label: "Niederlande" },
+                { value: "no", label: "Norwegen" },
+                { value: "at", label: "Österreich" },
+                { value: "pl", label: "Polen" },
+                { value: "pt", label: "Portugal" },
+                { value: "ro", label: "Rumänien" },
+                { value: "se", label: "Schweden" },
+                { value: "ch", label: "Schweiz" },
+                { value: "sk", label: "Slowakei" },
+                { value: "si", label: "Slowenien" },
+                { value: "es", label: "Spanien" },
+                { value: "cz", label: "Tschechien" },
+                { value: "hu", label: "Ungarn" },
+                { value: "gb", label: "Vereinigtes Königreich" },
+                { value: "cy", label: "Zypern" },
+            ],
+        },
+        { key: "vat_number", label: "UID-Nummer", type: "string", required: true },
+        { key: "email", label: "E-Mail", type: "string" },
+        { key: "phone", label: "Telefon", type: "string" },
+        { key: "website", label: "Website", type: "url" },
+        { key: "iban", label: "IBAN", type: "string" },
+        { key: "bic", label: "BIC", type: "string" },
+        { key: "company_register_number", label: "Firmenbuchnummer", type: "string" },
+        { key: "company_register_court", label: "Firmenbuchgericht", type: "string" },
+    ],
+});
+/**
+ * The shop's master data for server-side code. Precedence per key: stored in
+ * the Admin > `fallback` (e.g. a plugin's own medusa-config option). A
+ * missing base plugin fails with `UNEXPECTED_STATE`; read failures propagate.
+ */
+async function getShopMasterData(container, fallback) {
+    const resolved = await (0, settings_1.getPluginSettings)(container, exports.shopMasterDataDescriptor, fallback);
+    const values = {};
+    for (const [key, value] of Object.entries(resolved.values)) {
+        if (typeof value === "string") {
+            values[key] = value;
+        }
+    }
+    return {
+        values,
+        configured: resolved.configured,
+        missing: resolved.missing,
+    };
+}