@hartl-services/medusa-base 0.4.0 → 1.1.0

package/dist/files/types/public.d.ts

@@ -0,0 +1,90 @@
+export type CacheExpirationStrategy = "absolute" | "sliding";
+export interface S3CacheCredentials {
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+}
+export interface S3CacheOptions {
+    bucket?: string;
+    credentials?: S3CacheCredentials;
+    endpoint?: string;
+    forcePathStyle?: boolean;
+    region?: string;
+    storagePrefix?: string;
+}
+export interface FileGatewayOptions {
+    baseUrl?: string;
+    privateDownloadDurationSeconds?: number;
+    signingSecret?: string;
+}
+export interface S3CacheOptionsCache {
+    cleanupIntervalMs?: number;
+    dir?: string;
+    expirationStrategy?: CacheExpirationStrategy;
+    ttlMs?: number;
+}
+export interface LocalFileProviderOptions {
+    backendUrl?: string;
+    privateUploadDir?: string;
+    uploadDir?: string;
+}
+export interface S3CacheFileModuleConfigOptions {
+    cache?: S3CacheOptionsCache;
+    enabled?: boolean;
+    gateway?: FileGatewayOptions;
+    local?: LocalFileProviderOptions;
+    s3?: S3CacheOptions;
+}
+export interface FileModuleProviderConfiguration {
+    id: string;
+    options: Record<string, unknown>;
+    resolve: string;
+}
+export interface FileModuleConfiguration {
+    options: {
+        providers: FileModuleProviderConfiguration[];
+    };
+    resolve: "@medusajs/medusa/file";
+}
+export interface ValidatedS3CacheCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+export interface ValidatedS3CacheOptions {
+    bucket: string;
+    credentials?: ValidatedS3CacheCredentials;
+    endpoint?: string;
+    forcePathStyle: boolean;
+    region: string;
+    storagePrefix: string;
+}
+export interface ValidatedFileGatewayOptions {
+    baseUrl: string;
+    privateDownloadDurationSeconds: number;
+    signingSecret: string;
+}
+export interface ValidatedS3CacheProviderOptions {
+    cache: Required<S3CacheOptionsCache>;
+    gateway: ValidatedFileGatewayOptions;
+    s3: ValidatedS3CacheOptions;
+}
+/** Package name under which the gateway routes read the `files` options. */
+export declare const BASE_PLUGIN_RESOLVE = "@hartl-services/medusa-base";
+/**
+ * The `files` namespace of the base plugin options: what the `/files` gateway
+ * routes sign and verify with. `createS3CacheStorageConfig` returns it from the
+ * same validated input as the File Module provider, so every URL the provider
+ * signs is one the routes accept.
+ */
+export type FilesPluginOptions = {
+    gateway: {
+        signingSecret: string;
+    };
+};
+export interface S3CacheStorageConfiguration {
+    /** Register under `modules`: the File Module with this S3 provider. */
+    fileModule: FileModuleConfiguration;
+    /** Set as `files.gateway` in the options of the base plugin. */
+    gateway: FilesPluginOptions["gateway"];
+}

package/dist/files/types/public.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_PLUGIN_RESOLVE = void 0;
+/** Package name under which the gateway routes read the `files` options. */
+exports.BASE_PLUGIN_RESOLVE = "@hartl-services/medusa-base";

package/dist/modules/documents/domain/merchant.d.ts

@@ -0,0 +1,22 @@
+import type { DocumentMerchant, DocumentMerchantOption } from "../../../documents/types/documents";
+/** Shop master data keys (base plugin, `plugin_key: "shop"`) documents read. */
+export type DocumentMerchantKey = keyof DocumentMerchant;
+export type DocumentMerchantValues = Partial<Record<DocumentMerchantKey, string>>;
+/** Without these a financial document or packing list has no legal sender. */
+export declare const DOCUMENT_MERCHANT_REQUIRED_FIELDS: readonly ["legal_name", "address_line1", "postal_code", "city", "country_code"];
+/** Development placeholder UID: never printed on a document. */
+export declare const MERCHANT_VAT_PLACEHOLDER = "ATU00000000";
+/**
+ * The plugin's `merchant` option as a per-field fallback for the shop master
+ * data. Empty values are left out so they never shadow a declared default.
+ */
+export declare const merchantOptionToFallback: (option: DocumentMerchantOption | undefined) => DocumentMerchantValues;
+export type DocumentMerchantResolution = {
+    merchant: DocumentMerchant;
+    missing: [];
+} | {
+    merchant: null;
+    missing: DocumentMerchantKey[];
+};
+/** Maps resolved shop master data to the render input's `merchant`. */
+export declare const toDocumentMerchant: (values: DocumentMerchantValues) => DocumentMerchantResolution;

package/dist/modules/documents/domain/merchant.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDocumentMerchant = exports.merchantOptionToFallback = exports.MERCHANT_VAT_PLACEHOLDER = exports.DOCUMENT_MERCHANT_REQUIRED_FIELDS = void 0;
+/** Without these a financial document or packing list has no legal sender. */
+exports.DOCUMENT_MERCHANT_REQUIRED_FIELDS = [
+    "legal_name",
+    "address_line1",
+    "postal_code",
+    "city",
+    "country_code",
+];
+/** Development placeholder UID: never printed on a document. */
+exports.MERCHANT_VAT_PLACEHOLDER = "ATU00000000";
+const text = (value) => {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+};
+const vatNumber = (value) => {
+    const normalized = text(value);
+    return normalized &&
+        normalized.replace(/\s+/g, "").toUpperCase() === exports.MERCHANT_VAT_PLACEHOLDER
+        ? null
+        : normalized;
+};
+/**
+ * The plugin's `merchant` option as a per-field fallback for the shop master
+ * data. Empty values are left out so they never shadow a declared default.
+ */
+const merchantOptionToFallback = (option) => {
+    if (!option) {
+        return {};
+    }
+    const address = option.registeredAddress;
+    const entries = [
+        ["legal_name", option.legalName],
+        ["address_line1", address?.address1],
+        ["address_line2", address?.address2],
+        ["postal_code", address?.postalCode],
+        ["city", address?.city],
+        [
+            "country_code",
+            text(address?.countryCode ?? option.countryCode)?.toLowerCase(),
+        ],
+        ["vat_number", option.vatNumber],
+    ];
+    const fallback = {};
+    for (const [key, value] of entries) {
+        const normalized = text(value);
+        if (normalized) {
+            fallback[key] = normalized;
+        }
+    }
+    return fallback;
+};
+exports.merchantOptionToFallback = merchantOptionToFallback;
+/** Maps resolved shop master data to the render input's `merchant`. */
+const toDocumentMerchant = (values) => {
+    const missing = exports.DOCUMENT_MERCHANT_REQUIRED_FIELDS.filter((key) => !text(values[key]));
+    if (missing.length > 0) {
+        return { merchant: null, missing };
+    }
+    return {
+        merchant: {
+            legal_name: text(values.legal_name),
+            address_line1: text(values.address_line1),
+            address_line2: text(values.address_line2),
+            postal_code: text(values.postal_code),
+            city: text(values.city),
+            country_code: text(values.country_code).toLowerCase(),
+            vat_number: vatNumber(values.vat_number),
+            email: text(values.email),
+            phone: text(values.phone),
+            website: text(values.website),
+            iban: text(values.iban),
+            bic: text(values.bic),
+            company_register_number: text(values.company_register_number),
+            company_register_court: text(values.company_register_court),
+        },
+        missing: [],
+    };
+};
+exports.toDocumentMerchant = toDocumentMerchant;

package/dist/modules/documents/domain/options.d.ts

@@ -0,0 +1,34 @@
+import type { DocumentHtmlFactory } from "../../../documents/types/html-factory";
+import type { DocumentMerchantOption, DocumentPdfOptions } from "../../../documents/types/documents";
+import { type DocumentMerchantValues } from "./merchant";
+/** Used when the `documents.numbering.timeZone` option is not given. */
+export declare const DEFAULT_NUMBERING_TIME_ZONE = "Europe/Vienna";
+/** The `documents` namespace of the base plugin options. */
+export type DocumentPluginOptions = {
+    /**
+     * Replaces the built-in German document markup. Omit it to use
+     * `createDefaultDocumentHtmlFactory` with the `numbering.timeZone`.
+     */
+    htmlFactory?: DocumentHtmlFactory;
+    /**
+     * Fallback for the shop master data of the base plugin: used per field
+     * only where no value is stored there.
+     */
+    merchant?: DocumentMerchantOption;
+    numbering?: {
+        timeZone?: string;
+    };
+    pdf?: DocumentPdfOptions;
+};
+export type ResolvedDocumentPluginOptions = {
+    htmlFactory: DocumentHtmlFactory;
+    /** The `merchant` option keyed by shop master data field. */
+    merchantFallback: DocumentMerchantValues;
+    numbering: {
+        timeZone: string;
+    };
+    pdf: {
+        executablePath: string;
+    };
+};
+export declare const resolveDocumentPluginOptions: (options: DocumentPluginOptions | undefined) => ResolvedDocumentPluginOptions;

package/dist/modules/documents/domain/options.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDocumentPluginOptions = exports.DEFAULT_NUMBERING_TIME_ZONE = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const html_factory_1 = require("../../../documents/templates/html-factory");
+const merchant_1 = require("./merchant");
+/** Used when the `documents.numbering.timeZone` option is not given. */
+exports.DEFAULT_NUMBERING_TIME_ZONE = "Europe/Vienna";
+const resolveDocumentPluginOptions = (options) => {
+    const configuredTimeZone = options?.numbering?.timeZone;
+    const timeZone = configuredTimeZone === undefined
+        ? exports.DEFAULT_NUMBERING_TIME_ZONE
+        : configuredTimeZone.trim();
+    if (!timeZone) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "The documents plugin requires a numbering time zone.");
+    }
+    try {
+        new Intl.DateTimeFormat("en", { timeZone }).format();
+    }
+    catch {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `The documents numbering time zone '${timeZone}' is invalid.`);
+    }
+    if (options?.htmlFactory !== undefined &&
+        typeof options.htmlFactory !== "function") {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "The documents 'htmlFactory' option must be a function.");
+    }
+    if (options?.merchant !== undefined &&
+        (typeof options.merchant !== "object" || options.merchant === null)) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "The documents 'merchant' option must be an object.");
+    }
+    const executablePath = options?.pdf?.executablePath?.trim() || "google-chrome";
+    return {
+        htmlFactory: options?.htmlFactory ?? (0, html_factory_1.createDefaultDocumentHtmlFactory)({ timeZone }),
+        merchantFallback: (0, merchant_1.merchantOptionToFallback)(options?.merchant),
+        numbering: { timeZone },
+        pdf: { executablePath },
+    };
+};
+exports.resolveDocumentPluginOptions = resolveDocumentPluginOptions;

package/dist/public/config.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Environment helpers for a shop's `medusa-config.ts`. The configuration
+ * itself (which plugins run, static shop facts, defaults) lives in the shop;
+ * these helpers only read and validate deployment values so a misconfigured
+ * deployment fails at startup with the variable's name.
+ */
+export type ConfigurationPhase = "build" | "runtime";
+/**
+ * Placeholders for the variables Medusa core and the Stripe payment provider
+ * need. `medusa build` loads the configuration without deployment secrets;
+ * pass these (merged with the placeholders of the shop's other plugins) as
+ * `buildPlaceholders` to `requireEnvironment` so required-variable checks pass
+ * during the build. They never reach a running server.
+ */
+export declare const MEDUSA_BUILD_PLACEHOLDERS: Readonly<Record<string, string>>;
+export declare const optionalEnvironment: (environment: NodeJS.ProcessEnv, name: string) => string | undefined;
+/**
+ * Returns every named value or throws one error listing all missing names.
+ * During the build phase, the given `buildPlaceholders` stand in for
+ * deployment values; at runtime they are ignored.
+ */
+export declare const requireEnvironment: <Name extends string>(environment: NodeJS.ProcessEnv, names: readonly Name[], phase: ConfigurationPhase, buildPlaceholders: Readonly<Record<string, string>>) => Readonly<Record<Name, string>>;
+export declare const integerEnvironment: (environment: NodeJS.ProcessEnv, name: string, minimum: number, maximum: number) => number | undefined;
+export declare const booleanEnvironment: (environment: NodeJS.ProcessEnv, name: string, defaultValue: boolean) => boolean;
+/** Local development, tests and builds may use plain HTTP and SMTP. */
+export declare const allowsInsecureLocalServices: (environment: NodeJS.ProcessEnv, phase: ConfigurationPhase) => boolean;
+export declare const resolvePublicOrigin: (value: string, name: string, allowHttp: boolean) => string;
+/**
+ * Builds an absolute URL on a validated origin from a path that may contain
+ * customer-controlled parts (e.g. a locale). Protocol-relative paths, queries,
+ * fragments and backslashes are rejected so the URL can never leave the origin.
+ */
+export declare const shopUrl: (origin: string, path: string) => string;
+export declare const resolveStripe: (values: {
+    readonly STRIPE_API_KEY: string;
+    readonly STRIPE_WEBHOOK_SECRET: string;
+}) => {
+    readonly apiKey: string;
+    readonly webhookSecret: string;
+};
+export type RedisEventBusConfiguration = {
+    readonly url: string;
+};
+/**
+ * Redis is optional in development (Medusa then uses its local Event Bus),
+ * required at runtime everywhere else, and never used during a build.
+ * Production requires authenticated `rediss://` unless an insecure private
+ * network is explicitly accepted.
+ */
+export declare const resolveRedisEventBus: (environment: NodeJS.ProcessEnv, phase: ConfigurationPhase) => RedisEventBusConfiguration | undefined;
+/**
+ * Boot-time registrations of the plugin's built-in modules, from the same
+ * `@hartl-services/medusa-base/config` entry: the SMTP notification provider
+ * (E-Mail), the S3 file storage provider with its `/files` gateway part, and
+ * the default document markup.
+ */
+export * from "../email/config";
+export * from "../files/config";
+export * from "../documents/config";

package/dist/public/config.js

@@ -0,0 +1,185 @@
+"use strict";
+/* eslint-disable @medusajs/use-medusa-error-not-generic-error -- Startup configuration errors are not HTTP responses. */
+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 });
+exports.resolveRedisEventBus = exports.resolveStripe = exports.shopUrl = exports.resolvePublicOrigin = exports.allowsInsecureLocalServices = exports.booleanEnvironment = exports.integerEnvironment = exports.requireEnvironment = exports.optionalEnvironment = exports.MEDUSA_BUILD_PLACEHOLDERS = void 0;
+/**
+ * Placeholders for the variables Medusa core and the Stripe payment provider
+ * need. `medusa build` loads the configuration without deployment secrets;
+ * pass these (merged with the placeholders of the shop's other plugins) as
+ * `buildPlaceholders` to `requireEnvironment` so required-variable checks pass
+ * during the build. They never reach a running server.
+ */
+exports.MEDUSA_BUILD_PLACEHOLDERS = {
+    ADMIN_CORS: "http://localhost",
+    AUTH_CORS: "http://localhost",
+    COOKIE_SECRET: "build-placeholder",
+    DATABASE_URL: "postgres://build:build@localhost:5432/build",
+    JWT_SECRET: "build-placeholder",
+    MEDUSA_BACKEND_URL: "http://localhost",
+    STOREFRONT_URL: "http://localhost:8000",
+    STORE_CORS: "http://localhost",
+    STRIPE_API_KEY: "sk_test_build-placeholder",
+    STRIPE_WEBHOOK_SECRET: "whsec_build-placeholder",
+};
+const optionalEnvironment = (environment, name) => {
+    const value = environment[name]?.trim();
+    return value ? value : undefined;
+};
+exports.optionalEnvironment = optionalEnvironment;
+/**
+ * Returns every named value or throws one error listing all missing names.
+ * During the build phase, the given `buildPlaceholders` stand in for
+ * deployment values; at runtime they are ignored.
+ */
+const requireEnvironment = (environment, names, phase, buildPlaceholders) => {
+    const source = phase === "build" ? { ...environment, ...buildPlaceholders } : environment;
+    const missing = names.filter((name) => (0, exports.optionalEnvironment)(source, name) === undefined);
+    if (missing.length > 0) {
+        throw new TypeError(`Missing required environment variables: ${missing.join(", ")}.`);
+    }
+    return Object.fromEntries(names.map((name) => [name, (0, exports.optionalEnvironment)(source, name)]));
+};
+exports.requireEnvironment = requireEnvironment;
+const integerEnvironment = (environment, name, minimum, maximum) => {
+    const value = (0, exports.optionalEnvironment)(environment, name);
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) {
+        throw new TypeError(`${name} must be an integer from ${minimum} through ${maximum}.`);
+    }
+    return parsed;
+};
+exports.integerEnvironment = integerEnvironment;
+const booleanEnvironment = (environment, name, defaultValue) => {
+    const value = (0, exports.optionalEnvironment)(environment, name);
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (value !== "true" && value !== "false") {
+        throw new TypeError(`${name} must be either "true" or "false".`);
+    }
+    return value === "true";
+};
+exports.booleanEnvironment = booleanEnvironment;
+/** Local development, tests and builds may use plain HTTP and SMTP. */
+const allowsInsecureLocalServices = (environment, phase) => phase === "build" ||
+    environment.NODE_ENV === "development" ||
+    environment.NODE_ENV === "test";
+exports.allowsInsecureLocalServices = allowsInsecureLocalServices;
+const resolvePublicOrigin = (value, name, allowHttp) => {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TypeError(`${name} must be a valid HTTP(S) origin.`);
+    }
+    if ((url.protocol !== "https:" && url.protocol !== "http:") ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash) {
+        throw new TypeError(`${name} must be a valid HTTP(S) origin.`);
+    }
+    if (!allowHttp && url.protocol !== "https:") {
+        throw new TypeError(`${name} must use HTTPS outside development and test.`);
+    }
+    return url.origin;
+};
+exports.resolvePublicOrigin = resolvePublicOrigin;
+/**
+ * Builds an absolute URL on a validated origin from a path that may contain
+ * customer-controlled parts (e.g. a locale). Protocol-relative paths, queries,
+ * fragments and backslashes are rejected so the URL can never leave the origin.
+ */
+const shopUrl = (origin, path) => {
+    if (!path ||
+        path !== path.trim() ||
+        !path.startsWith("/") ||
+        path.startsWith("//") ||
+        path.includes("?") ||
+        path.includes("#") ||
+        path.includes("\\")) {
+        throw new TypeError(`Shop URL path "${path}" is not a plain absolute path.`);
+    }
+    return new URL(path, origin).toString();
+};
+exports.shopUrl = shopUrl;
+const resolveStripe = (values) => {
+    if (!values.STRIPE_API_KEY.startsWith("sk_")) {
+        throw new TypeError("STRIPE_API_KEY must be a Stripe secret key (sk_...), not a publishable key.");
+    }
+    if (!values.STRIPE_WEBHOOK_SECRET.startsWith("whsec_")) {
+        throw new TypeError("STRIPE_WEBHOOK_SECRET must be a Stripe webhook signing secret (whsec_...).");
+    }
+    return {
+        apiKey: values.STRIPE_API_KEY,
+        webhookSecret: values.STRIPE_WEBHOOK_SECRET,
+    };
+};
+exports.resolveStripe = resolveStripe;
+/**
+ * Redis is optional in development (Medusa then uses its local Event Bus),
+ * required at runtime everywhere else, and never used during a build.
+ * Production requires authenticated `rediss://` unless an insecure private
+ * network is explicitly accepted.
+ */
+const resolveRedisEventBus = (environment, phase) => {
+    if (phase === "build") {
+        return undefined;
+    }
+    const url = (0, exports.optionalEnvironment)(environment, "REDIS_URL");
+    if (!url) {
+        if (environment.NODE_ENV !== "development") {
+            throw new TypeError("Missing required environment variables: REDIS_URL.");
+        }
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new TypeError("REDIS_URL must be a valid Redis URL.");
+    }
+    if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+        throw new TypeError("REDIS_URL must use redis:// or rediss://.");
+    }
+    if (environment.NODE_ENV === "production") {
+        if (!parsed.password) {
+            throw new TypeError("Production REDIS_URL must include authentication.");
+        }
+        if (parsed.protocol !== "rediss:" &&
+            !(0, exports.booleanEnvironment)(environment, "REDIS_ALLOW_INSECURE_PRIVATE_NETWORK", false)) {
+            throw new TypeError("Production REDIS_URL must use rediss:// unless REDIS_ALLOW_INSECURE_PRIVATE_NETWORK=true.");
+        }
+    }
+    return { url };
+};
+exports.resolveRedisEventBus = resolveRedisEventBus;
+/**
+ * Boot-time registrations of the plugin's built-in modules, from the same
+ * `@hartl-services/medusa-base/config` entry: the SMTP notification provider
+ * (E-Mail), the S3 file storage provider with its `/files` gateway part, and
+ * the default document markup.
+ */
+__exportStar(require("../email/config"), exports);
+__exportStar(require("../files/config"), exports);
+__exportStar(require("../documents/config"), exports);

package/dist/public/descriptor.js

@@ -11,6 +11,7 @@ const SETTING_TYPES = new Set([
     "boolean",
     "secret",
     "select",
+    "image",
 ]);
 const ACTION_MODES = new Set(["sync", "background"]);
 const ADMIN_PAGE_PREFIX = "/settings/hartl-services/";
@@ -33,6 +34,7 @@ const defaultMatchesType = (setting) => {
         case "string":
             return hasText(value);
         case "url":
+        case "image":
             return typeof value === "string" && isHttpUrl(value);
         case "number":
             return typeof value === "number" && Number.isFinite(value);

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/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/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

@@ -5,7 +5,7 @@ import type { PluginSettingsFallback } from "./types";
  * 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>;
+export declare const shopMasterDataDescriptor: import("./types").PluginFeatureDescriptor<string, "country_code" | "legal_name" | "address_line1" | "address_line2" | "postal_code" | "city" | "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. */