@hartl-services/medusa-base 0.3.0 → 1.0.0

package/.medusa/server/src/providers/smtp/service.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmtpNotificationService = exports.SMTP_TIMEOUTS = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const nodemailer_1 = __importDefault(require("nodemailer"));
+const service_1 = require("../../modules/email/service");
+const types_1 = require("./types");
+exports.SMTP_TIMEOUTS = {
+    connection: 10_000,
+    greeting: 10_000,
+    socket: 30_000,
+};
+const emailAddressPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const connectionFailureCodes = new Set(["ECONNREFUSED", "EDNS"]);
+const invalidOptions = () => {
+    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Invalid SMTP notification provider options.");
+};
+const isNonEmptyString = (value) => typeof value === "string" && Boolean(value.trim());
+const deliveryIdentity = (notification) => {
+    const providerData = notification.provider_data;
+    const hasIdentity = Boolean(providerData && "message_id" in providerData);
+    if (!hasIdentity) {
+        return null;
+    }
+    const notificationId = notification.id;
+    if (!providerData ||
+        !isNonEmptyString(providerData.attempt_id) ||
+        !isNonEmptyString(providerData.kind) ||
+        !isNonEmptyString(providerData.message_id) ||
+        !isNonEmptyString(notificationId)) {
+        return throwSentinel(types_1.SMTP_FAILURE_SENTINELS.invalidContent);
+    }
+    return {
+        attemptId: providerData.attempt_id,
+        kind: providerData.kind,
+        messageId: providerData.message_id,
+        notificationId,
+    };
+};
+const classifySmtpFailure = (error) => {
+    if (!error || typeof error !== "object") {
+        return types_1.SMTP_FAILURE_SENTINELS.outcomeUnknown;
+    }
+    const smtpError = error;
+    const responseCode = Number(smtpError.responseCode);
+    if (responseCode >= 400 && responseCode < 500) {
+        return types_1.SMTP_FAILURE_SENTINELS.transientRejection;
+    }
+    if (responseCode >= 500 && responseCode < 600) {
+        return types_1.SMTP_FAILURE_SENTINELS.permanentRejection;
+    }
+    const code = typeof smtpError.code === "string" ? smtpError.code : "";
+    const command = typeof smtpError.command === "string"
+        ? smtpError.command.toUpperCase()
+        : "";
+    const syscall = typeof smtpError.syscall === "string"
+        ? smtpError.syscall.toLowerCase()
+        : "";
+    if ((connectionFailureCodes.has(code) && command !== "DATA") ||
+        (code === "ESOCKET" && command === "CONN" && syscall === "connect")) {
+        return types_1.SMTP_FAILURE_SENTINELS.connectionFailed;
+    }
+    return types_1.SMTP_FAILURE_SENTINELS.outcomeUnknown;
+};
+const throwSentinel = (sentinel) => {
+    throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, sentinel);
+};
+class SmtpNotificationService extends utils_1.AbstractNotificationProviderService {
+    constructor(dependencies, options) {
+        super();
+        this.logger_ = dependencies.logger;
+        this.options_ = options;
+        this.pgConnection_ = dependencies[utils_1.ContainerRegistrationKeys.PG_CONNECTION];
+        if (options.transport) {
+            this.transport_ = options.transport;
+            return;
+        }
+        const transport = nodemailer_1.default.createTransport({
+            auth: {
+                pass: options.smtp.password,
+                user: options.smtp.user,
+            },
+            connectionTimeout: exports.SMTP_TIMEOUTS.connection,
+            greetingTimeout: exports.SMTP_TIMEOUTS.greeting,
+            host: options.smtp.host,
+            port: options.smtp.port,
+            requireTLS: options.smtp.requireTls,
+            secure: options.smtp.secure,
+            socketTimeout: exports.SMTP_TIMEOUTS.socket,
+        });
+        this.transport_ = {
+            sendMail: (message) => transport.sendMail(message),
+        };
+    }
+    static validateOptions(options) {
+        if (!options || typeof options !== "object" || Array.isArray(options)) {
+            invalidOptions();
+        }
+        const channels = options.channels;
+        const smtp = options.smtp;
+        if (!Array.isArray(channels) ||
+            channels.length !== 1 ||
+            channels[0] !== "email" ||
+            typeof smtp !== "object" ||
+            smtp === null ||
+            Array.isArray(smtp)) {
+            invalidOptions();
+        }
+        const configuration = smtp;
+        if (!isNonEmptyString(configuration.from) ||
+            !emailAddressPattern.test(configuration.from) ||
+            !isNonEmptyString(configuration.host) ||
+            !isNonEmptyString(configuration.password) ||
+            !Number.isInteger(configuration.port) ||
+            configuration.port <= 0 ||
+            configuration.port > 65_535 ||
+            typeof configuration.requireTls !== "boolean" ||
+            typeof configuration.secure !== "boolean" ||
+            !isNonEmptyString(configuration.user)) {
+            invalidOptions();
+        }
+    }
+    async send(notification) {
+        const content = notification.content;
+        const html = content?.html;
+        const subject = content?.subject;
+        const text = content?.text;
+        if (!isNonEmptyString(html) ||
+            !isNonEmptyString(subject) ||
+            !isNonEmptyString(text)) {
+            return throwSentinel(types_1.SMTP_FAILURE_SENTINELS.invalidContent);
+        }
+        const attachments = notification.attachments?.map((attachment) => {
+            const contentDisposition = attachment.disposition === "inline" ? "inline" : "attachment";
+            return {
+                ...(contentDisposition === "inline" && attachment.id
+                    ? { cid: attachment.id }
+                    : {}),
+                content: Buffer.from(attachment.content, "binary"),
+                contentDisposition,
+                contentType: attachment.content_type,
+                filename: attachment.filename,
+            };
+        });
+        const from = notification.from && emailAddressPattern.test(notification.from)
+            ? notification.from
+            : this.options_.smtp.from;
+        const identity = deliveryIdentity(notification);
+        const sendMail = async () => {
+            try {
+                return {
+                    outcome: "sent",
+                    result: await this.transport_.sendMail({
+                        attachments,
+                        from,
+                        html,
+                        subject,
+                        text,
+                        to: notification.to,
+                    }),
+                };
+            }
+            catch (error) {
+                return { error, outcome: "failed" };
+            }
+        };
+        let delivery;
+        if (identity) {
+            if (!this.pgConnection_) {
+                this.logger_.error(`smtp: delivery fence failed (${types_1.SMTP_FAILURE_SENTINELS.outcomeUnknown})`);
+                return throwSentinel(types_1.SMTP_FAILURE_SENTINELS.outcomeUnknown);
+            }
+            try {
+                delivery = await this.pgConnection_.transaction(async (transaction) => {
+                    const guarded = await transaction.raw(`update "email_attempt" as a
+             set "lease_started_at" = clock_timestamp(),
+                 "lease_expires_at" = clock_timestamp() + (? * interval '1 millisecond'),
+                 "notification_id" = ?, "updated_at" = clock_timestamp()
+             from "email_message" as m
+             where a."id" = ? and a."message_id" = ?
+               and a."status" = 'processing' and a."attempt_token" is not null
+               and a."deleted_at" is null and a."notification_id" is null
+               and m."id" = a."message_id" and m."kind" = ?
+               and m."status" = 'sending' and m."deleted_at" is null
+             returning a."id"`, [
+                        service_1.EMAIL_ATTEMPT_LEASE_MS,
+                        identity.notificationId,
+                        identity.attemptId,
+                        identity.messageId,
+                        identity.kind,
+                    ]);
+                    if (guarded.rowCount !== 1) {
+                        throw new Error("Email attempt delivery fence was not acquired.");
+                    }
+                    const result = await sendMail();
+                    const renewed = await transaction.raw(`update "email_attempt"
+             set "lease_started_at" = clock_timestamp(),
+                 "lease_expires_at" = clock_timestamp() + (? * interval '1 millisecond'),
+                 "updated_at" = clock_timestamp()
+             where "id" = ? and "message_id" = ?
+               and "status" = 'processing' and "attempt_token" is not null
+               and "notification_id" = ? and "deleted_at" is null
+             returning "id"`, [
+                        service_1.EMAIL_ATTEMPT_LEASE_MS,
+                        identity.attemptId,
+                        identity.messageId,
+                        identity.notificationId,
+                    ]);
+                    if (renewed.rowCount !== 1) {
+                        throw new Error("Email attempt delivery fence was lost.");
+                    }
+                    return result;
+                });
+            }
+            catch {
+                this.logger_.error(`smtp: delivery fence failed (${types_1.SMTP_FAILURE_SENTINELS.outcomeUnknown})`);
+                return throwSentinel(types_1.SMTP_FAILURE_SENTINELS.outcomeUnknown);
+            }
+        }
+        else {
+            delivery = await sendMail();
+        }
+        if (delivery.outcome === "sent") {
+            return delivery.result.messageId ? { id: delivery.result.messageId } : {};
+        }
+        const sentinel = classifySmtpFailure(delivery.error);
+        this.logger_.error(`smtp: send failed (${sentinel})`);
+        return throwSentinel(sentinel);
+    }
+}
+exports.SmtpNotificationService = SmtpNotificationService;
+SmtpNotificationService.identifier = "smtp";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/providers/smtp/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/providers/smtp/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMTP_FAILURE_SENTINELS = void 0;
+exports.SMTP_FAILURE_SENTINELS = {
+    connectionFailed: "EMAIL_SMTP_CONNECTION_FAILED",
+    invalidContent: "EMAIL_SMTP_INVALID_CONTENT",
+    outcomeUnknown: "EMAIL_SMTP_OUTCOME_UNKNOWN",
+    permanentRejection: "EMAIL_SMTP_PERMANENT_REJECTION",
+    transientRejection: "EMAIL_SMTP_TRANSIENT_REJECTION",
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3NtdHAvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRWEsUUFBQSxzQkFBc0IsR0FBRztJQUNwQyxnQkFBZ0IsRUFBRSw4QkFBOEI7SUFDaEQsY0FBYyxFQUFFLDRCQUE0QjtJQUM1QyxjQUFjLEVBQUUsNEJBQTRCO0lBQzVDLGtCQUFrQixFQUFFLGdDQUFnQztJQUNwRCxrQkFBa0IsRUFBRSxnQ0FBZ0M7Q0FDNUMsQ0FBQyJ9

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

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

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

@@ -0,0 +1,186 @@
+"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);
+//# sourceMappingURL=data:application/json;base64,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