npm - customer-registration - Versions diffs - 0.0.104 → 0.0.106 - Mend

customer-registration 0.0.104 → 0.0.106

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/.medusa/server/src/api/auth/customer/emailpass/reset-password/route.js ADDED Viewed

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const generate_jwt_token_1 = require("@medusajs/medusa/api/auth/utils/generate-jwt-token");
+/**
+ * Send password reset email using notification service
+ */
+async function sendPasswordResetEmail(email, token, container) {
+    console.log("[reset-password] Sending password reset email directly...");
+    const notificationService = container.resolve(utils_1.Modules.NOTIFICATION);
+    if (!notificationService) {
+        console.error("[reset-password] Notification service is not configured");
+        return;
+    }
+    // Get storefront URL from environment or config
+    let storefrontUrl = "http://localhost:8000";
+    try {
+        const config = container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+        storefrontUrl =
+            process.env.STOREFRONT_URL ||
+                config?.projectConfig?.storefrontUrl ||
+                "http://localhost:8000";
+    }
+    catch (error) {
+        console.warn("[reset-password] Failed to resolve config, using default storefront URL:", error);
+    }
+    // Build reset URL with token and email as query parameters
+    const resetUrl = `${storefrontUrl}/reset-password?token=${encodeURIComponent(token)}&email=${encodeURIComponent(email)}`;
+    // Prepare HTML and text content
+    const htmlContent = `
+    <html>
+      <body>
+        <h2>Reset Your Password</h2>
+        <p>Hello,</p>
+        <p>You requested to reset your password. Click the link below to reset it:</p>
+        <p><a href="${resetUrl}">Reset Password</a></p>
+        <p>Or use this token: <code>${token}</code></p>
+        <p>This link will expire in 1 hour.</p>
+        <p>If you didn't request a password reset, please ignore this email.</p>
+        <p>Best regards,<br>Your Team</p>
+      </body>
+    </html>
+  `.trim();
+    const textContent = `Reset Your Password\n\nClick this link to reset your password: ${resetUrl}\n\nToken: ${token}\n\nThis link will expire in 1 hour.\n\nIf you didn't request a password reset, please ignore this email.`;
+    // Prepare email payload matching notification service structure
+    // Include multiple fields for different SMTP provider expectations
+    const payload = {
+        to: email,
+        channel: "email",
+        data: {
+            subject: "Reset Your Password",
+            email,
+            token,
+            reset_url: resetUrl,
+            expires_in: "1 hour",
+            html: htmlContent,
+            text: textContent,
+        },
+        // Root level fields for SMTP providers
+        html: htmlContent,
+        text: textContent,
+        body: htmlContent, // Some providers expect 'body' field
+        template: htmlContent, // Some providers expect 'template' field
+        subject: "Reset Your Password", // Include subject at root level too
+    };
+    // Log payload structure (sanitized for security)
+    console.log("[reset-password] Email payload structure:", {
+        to: payload.to,
+        channel: payload.channel,
+        subject: payload.subject,
+        hasHtml: !!payload.html,
+        hasText: !!payload.text,
+        hasBody: !!payload.body,
+        hasTemplate: !!payload.template,
+        dataKeys: Object.keys(payload.data || {}),
+        htmlLength: payload.html?.length || 0,
+        textLength: payload.text?.length || 0,
+    });
+    try {
+        if (typeof notificationService.create === "function") {
+            console.log("[reset-password] Using notificationService.create method");
+            await notificationService.create(payload);
+            console.log(`[reset-password] ✓ Password reset email sent successfully to ${email}`);
+        }
+        else if (typeof notificationService.createNotifications === "function") {
+            console.log("[reset-password] Using notificationService.createNotifications method");
+            await notificationService.createNotifications([payload]);
+            console.log(`[reset-password] ✓ Password reset email sent successfully to ${email}`);
+        }
+        else {
+            console.error("[reset-password] Notification service does not support sending notifications");
+        }
+    }
+    catch (error) {
+        console.error(`[reset-password] Failed to send password reset email to ${email}:`, error);
+        if (error instanceof Error) {
+            console.error("[reset-password] Error details:", {
+                message: error.message,
+                stack: error.stack,
+            });
+        }
+        throw error;
+    }
+}
+/**
+ * Password reset request endpoint
+ *
+ * This endpoint matches Medusa's built-in `/auth/{actor_type}/{provider}/reset-password` route behavior.
+ * It generates a password reset token and sends an email.
+ *
+ * Note: This custom route overrides Medusa's built-in route. The subscriber listens to
+ * `auth.password_reset` event (emitted by Medusa's built-in route) but since we're overriding
+ * the route, we send the email directly here.
+ *
+ * To use Medusa's built-in route instead, remove this file and update the subscriber
+ * to listen to `auth.password_reset` event.
+ */
+const POST = async (req, res) => {
+    // Accept 'identifier' (Medusa's built-in route format) or 'email' for backward compatibility
+    const { identifier, email } = req.body;
+    const userEmail = identifier || email;
+    if (!userEmail || typeof userEmail !== "string" || !userEmail.trim()) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Email (identifier) is required");
+    }
+    const normalizedEmail = userEmail.toLowerCase().trim();
+    try {
+        // Find customer by email
+        const knex = req.scope.resolve(utils_1.ContainerRegistrationKeys.PG_CONNECTION);
+        if (!knex) {
+            throw new Error("Database connection not available");
+        }
+        const result = await knex.raw(`SELECT id FROM customer WHERE email = ? LIMIT 1`, [normalizedEmail]);
+        const row = result.rows?.[0] || result[0]?.[0];
+        const customer_id = row?.id;
+        // If customer doesn't exist, return success anyway (security: don't reveal if email exists)
+        // This matches Medusa's built-in route behavior
+        if (!customer_id) {
+            return res.status(201).json({});
+        }
+        // Get auth identity from provider_identity table
+        const providerIdentityResult = await knex.raw(`SELECT pi.id, pi.entity_id, pi.provider, ai.id as auth_identity_id
+       FROM provider_identity pi
+       LEFT JOIN auth_identity ai ON pi.auth_identity_id = ai.id
+       WHERE pi.entity_id = ? AND pi.provider = 'emailpass'
+       LIMIT 1`, [normalizedEmail]);
+        const providerIdentity = providerIdentityResult.rows?.[0] || providerIdentityResult[0]?.[0];
+        if (!providerIdentity || !providerIdentity.auth_identity_id) {
+            // Return success for security (don't reveal if email exists)
+            return res.status(201).json({});
+        }
+        // Get AUTH service to retrieve the full auth identity object
+        const authService = req.scope.resolve(utils_1.Modules.AUTH);
+        const authIdentity = await authService.retrieveAuthIdentity(providerIdentity.auth_identity_id);
+        if (!authIdentity) {
+            // Return success for security (don't reveal if email exists)
+            return res.status(201).json({});
+        }
+        // Generate reset token (JWT) with 1 hour expiration
+        // Using the same method Medusa's built-in route uses
+        const config = req.scope.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+        const { http } = config.projectConfig;
+        const resetToken = (0, generate_jwt_token_1.generateJwtTokenForAuthIdentity)({
+            authIdentity,
+            actorType: "customer",
+            authProvider: "emailpass",
+        }, {
+            secret: http.jwtSecret,
+            expiresIn: "1h", // 1 hour expiration for reset token
+            options: http.jwtOptions,
+        });
+        // Send password reset email
+        // Note: Medusa's built-in route would emit 'auth.password_reset' event here
+        // Since we're overriding the route, we send the email directly
+        try {
+            await sendPasswordResetEmail(normalizedEmail, resetToken, req.scope);
+        }
+        catch (emailError) {
+            console.error("[reset-password] Failed to send email:", emailError);
+            // Continue anyway - don't reveal if email exists
+        }
+        // Return 201 (Created) to match Medusa's built-in route response
+        return res.status(201).json({});
+    }
+    catch (error) {
+        // Even on error, return success to prevent email enumeration attacks
+        // This matches Medusa's built-in route behavior
+        console.error("[reset-password] Error processing reset request:", error);
+        return res.status(201).json({});
+    }
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/auth/customer/emailpass/update/route.js ADDED Viewed

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Password reset completion endpoint
+ *
+ * This endpoint uses Medusa's built-in AUTH module updateProvider method
+ * to update the customer's password. The AUTH module handles:
+ * 1. Token validation (from Authorization header)
+ * 2. Password hashing
+ * 3. Database updates
+ *
+ * This matches Medusa's built-in `/auth/{actor_type}/{provider}/update` route behavior.
+ */
+const POST = async (req, res) => {
+    const { email, password } = req.body;
+    // Get token from Authorization header (required by Medusa's built-in route)
+    const resetToken = req.headers.authorization?.replace("Bearer ", "");
+    if (!resetToken) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Reset token is required. Provide it in the 'Authorization: Bearer {token}' header");
+    }
+    if (!email || typeof email !== "string" || !email.trim()) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Email is required");
+    }
+    if (!password || typeof password !== "string" || password.length < 8) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Password is required and must be at least 8 characters");
+    }
+    const normalizedEmail = email.toLowerCase().trim();
+    try {
+        // Get AUTH service
+        const authService = req.scope.resolve(utils_1.Modules.AUTH);
+        // Use Medusa's built-in updateProvider method
+        // This method validates the token, hashes the password, and updates it in the database
+        // Pass the token in the data object (matching SDK behavior)
+        const result = await authService.updateProvider("emailpass", {
+            entity_id: normalizedEmail,
+            password: password,
+            token: resetToken,
+        });
+        // updateProvider returns the updated auth identity on success
+        if (!result) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNAUTHORIZED, "Failed to reset password. Invalid or expired token.");
+        }
+        return res.status(200).json({
+            message: "Password reset successfully",
+            success: true,
+        });
+    }
+    catch (error) {
+        // Re-throw MedusaError as-is
+        if (error instanceof utils_1.MedusaError) {
+            throw error;
+        }
+        // Handle unexpected errors
+        console.error("[reset-password-complete] Unexpected error:", error);
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Failed to reset password: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/store/customers/change-password/route.js ADDED Viewed

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const change_password_1 = __importDefault(require("../../../../workflows/change-password"));
+const POST = async (req, res) => {
+    // Get customer from auth context
+    const authContext = req.auth_context;
+    const customerId = authContext?.actor_id || authContext?.user_id;
+    if (!customerId) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNAUTHORIZED, "Authentication required");
+    }
+    const { old_password, new_password, confirm_password } = req.body;
+    if (!old_password) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Current password is required");
+    }
+    if (!new_password) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "New password is required");
+    }
+    if (!confirm_password) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Confirm password is required");
+    }
+    try {
+        // Execute change password workflow (validates password, verifies old password, and updates password)
+        const { result } = await (0, change_password_1.default)(req.scope).run({
+            input: {
+                customer_id: customerId,
+                old_password,
+                new_password,
+                confirm_password,
+            },
+        });
+        return res.status(200).json({
+            message: "Password changed successfully",
+            customer_id: result.customer_id,
+        });
+    }
+    catch (error) {
+        // Re-throw MedusaError as-is
+        if (error instanceof utils_1.MedusaError) {
+            throw error;
+        }
+        // Handle unexpected errors
+        console.error("[change-password] Unexpected error:", error);
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to change password");
+    }
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/store/customers/otp/verify/route.js CHANGED Viewed

@@ -9,7 +9,6 @@ const otp_verification_1 = require("../../../../../modules/otp-verification");
 const otp_verification_2 = require("../../../../../modules/otp-verification/models/otp-verification");
 const verify_email_1 = __importDefault(require("../../../../../workflows/verify-email"));
 const verify_phone_1 = __importDefault(require("../../../../../workflows/verify-phone"));
-const generate_password_reset_token_1 = __importDefault(require("../../../../../workflows/generate-password-reset-token"));
 const POST = async (req, res) => {
     const { token, code } = req.body;
     if (!token) {
@@ -54,22 +53,10 @@ const POST = async (req, res) => {
             phone_verified: workflowResult.phone_verified,
         };
     }
-    else if (verifyResult.type === otp_verification_2.OtpPurpose.FORGOT_PASSWORD) {
-        const { result: workflowResult } = await (0, generate_password_reset_token_1.default)(req.scope).run({
-            input: {
-                customer_id: verifyResult.customer_id,
-            },
-        });
-        result = {
-            verified: true,
-            reset_token: workflowResult.token,
-            expires_in: workflowResult.expires_in,
-        };
-    }
     else {
         throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Invalid verification type");
     }
     return res.status(200).json(result);
 };
 exports.POST = POST;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/helpers/base-client.js ADDED Viewed

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientRequest = exports.buildHeaders = exports.normalizeBaseUrl = void 0;
+const normalizeBaseUrl = (baseUrl) => {
+    if (!baseUrl) {
+        return "";
+    }
+    return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+};
+exports.normalizeBaseUrl = normalizeBaseUrl;
+const buildHeaders = (options) => {
+    const headers = {
+        "Content-Type": "application/json",
+        ...(options.headers ?? {}),
+    };
+    const hasPublishableHeader = Object.keys(headers).some((key) => key.toLowerCase() === "x-publishable-api-key");
+    if (options.publishableApiKey && !hasPublishableHeader) {
+        headers["x-publishable-api-key"] = options.publishableApiKey;
+    }
+    return headers;
+};
+exports.buildHeaders = buildHeaders;
+const getClientRequest = (client) => {
+    if (!client) {
+        return undefined;
+    }
+    if ("request" in client && typeof client.request === "function") {
+        return client.request.bind(client);
+    }
+    if ("client" in client && typeof client.client?.request === "function") {
+        return client.client.request.bind(client.client);
+    }
+    return undefined;
+};
+exports.getClientRequest = getClientRequest;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvaGVscGVycy9iYXNlLWNsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFvQ08sTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLE9BQWdCLEVBQUUsRUFBRTtJQUNuRCxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDYixPQUFPLEVBQUUsQ0FBQTtJQUNYLENBQUM7SUFDRCxPQUFPLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQTtBQUMvRCxDQUFDLENBQUE7QUFMWSxRQUFBLGdCQUFnQixvQkFLNUI7QUFFTSxNQUFNLFlBQVksR0FBRyxDQUFDLE9BQStCLEVBQUUsRUFBRTtJQUM5RCxNQUFNLE9BQU8sR0FBMkI7UUFDdEMsY0FBYyxFQUFFLGtCQUFrQjtRQUNsQyxHQUFHLENBQUMsT0FBTyxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUM7S0FDM0IsQ0FBQTtJQUVELE1BQU0sb0JBQW9CLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQ3BELENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLEtBQUssdUJBQXVCLENBQ3ZELENBQUE7SUFFRCxJQUFJLE9BQU8sQ0FBQyxpQkFBaUIsSUFBSSxDQUFDLG9CQUFvQixFQUFFLENBQUM7UUFDdkQsT0FBTyxDQUFDLHVCQUF1QixDQUFDLEdBQUcsT0FBTyxDQUFDLGlCQUFpQixDQUFBO0lBQzlELENBQUM7SUFFRCxPQUFPLE9BQU8sQ0FBQTtBQUNoQixDQUFDLENBQUE7QUFmWSxRQUFBLFlBQVksZ0JBZXhCO0FBRU0sTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLE1BQXlCLEVBQUUsRUFBRTtJQUM1RCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDWixPQUFPLFNBQVMsQ0FBQTtJQUNsQixDQUFDO0lBRUQsSUFBSSxTQUFTLElBQUksTUFBTSxJQUFJLE9BQU8sTUFBTSxDQUFDLE9BQU8sS0FBSyxVQUFVLEVBQUUsQ0FBQztRQUNoRSxPQUFPLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQ3BDLENBQUM7SUFFRCxJQUFJLFFBQVEsSUFBSSxNQUFNLElBQUksT0FBTyxNQUFNLENBQUMsTUFBTSxFQUFFLE9BQU8sS0FBSyxVQUFVLEVBQUUsQ0FBQztRQUN2RSxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDbEQsQ0FBQztJQUVELE9BQU8sU0FBUyxDQUFBO0FBQ2xCLENBQUMsQ0FBQTtBQWRZLFFBQUEsZ0JBQWdCLG9CQWM1QiJ9

package/.medusa/server/src/helpers/index.js ADDED Viewed

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompletePasswordReset = exports.completePasswordReset = exports.createRequestPasswordReset = exports.requestPasswordReset = exports.getClientRequest = exports.buildHeaders = exports.normalizeBaseUrl = void 0;
+// Base client utilities
+var base_client_1 = require("./base-client");
+Object.defineProperty(exports, "normalizeBaseUrl", { enumerable: true, get: function () { return base_client_1.normalizeBaseUrl; } });
+Object.defineProperty(exports, "buildHeaders", { enumerable: true, get: function () { return base_client_1.buildHeaders; } });
+Object.defineProperty(exports, "getClientRequest", { enumerable: true, get: function () { return base_client_1.getClientRequest; } });
+// Password reset helpers
+var reset_password_1 = require("./reset-password");
+Object.defineProperty(exports, "requestPasswordReset", { enumerable: true, get: function () { return reset_password_1.requestPasswordReset; } });
+Object.defineProperty(exports, "createRequestPasswordReset", { enumerable: true, get: function () { return reset_password_1.createRequestPasswordReset; } });
+var reset_password_2 = require("./reset-password");
+Object.defineProperty(exports, "completePasswordReset", { enumerable: true, get: function () { return reset_password_2.completePasswordReset; } });
+Object.defineProperty(exports, "createCompletePasswordReset", { enumerable: true, get: function () { return reset_password_2.createCompletePasswordReset; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx3QkFBd0I7QUFDeEIsNkNBTXNCO0FBSHBCLCtHQUFBLGdCQUFnQixPQUFBO0FBQ2hCLDJHQUFBLFlBQVksT0FBQTtBQUNaLCtHQUFBLGdCQUFnQixPQUFBO0FBR2xCLHlCQUF5QjtBQUN6QixtREFNeUI7QUFGdkIsc0hBQUEsb0JBQW9CLE9BQUE7QUFDcEIsNEhBQUEsMEJBQTBCLE9BQUE7QUFHNUIsbURBTXlCO0FBRnZCLHVIQUFBLHFCQUFxQixPQUFBO0FBQ3JCLDZIQUFBLDJCQUEyQixPQUFBIn0=

package/.medusa/server/src/helpers/reset-password.js ADDED Viewed

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompletePasswordReset = exports.createRequestPasswordReset = exports.completePasswordReset = exports.requestPasswordReset = void 0;
+const base_client_1 = require("./base-client");
+const RESET_PASSWORD_ENDPOINT = "/auth/customer/emailpass/reset-password";
+const COMPLETE_PASSWORD_RESET_ENDPOINT = "/auth/customer/emailpass/update";
+const resolveEndpoint = (defaultEndpoint, endpoint) => endpoint?.startsWith("/") ? endpoint : defaultEndpoint;
+/**
+ * Request a password reset for a customer
+ *
+ * This function calls the password reset endpoint which generates a JWT reset token
+ * and sends a password reset email to the customer.
+ *
+ * The API returns an empty object `{}` with 201 status for security reasons
+ * (doesn't reveal if email exists to prevent email enumeration attacks).
+ *
+ * @param input - Password reset request input
+ * @param options - Transport options (baseUrl, client, publishableApiKey, etc.)
+ * @returns Promise resolving to the reset request response (empty object on success)
+ *
+ * @example
+ * ```typescript
+ * import { requestPasswordReset } from "customer-registration/helpers"
+ *
+ * // Basic usage
+ * const result = await requestPasswordReset(
+ *   { email: "customer@example.com" },
+ *   { baseUrl: "https://store.example.com", publishableApiKey: "pk_..." }
+ * )
+ *
+ * // With Medusa SDK client
+ * import { sdk } from "@medusajs/js-sdk"
+ * const result = await requestPasswordReset(
+ *   { email: "customer@example.com" },
+ *   { client: sdk }
+ * )
+ * ```
+ */
+const requestPasswordReset = async (input, options = {}) => {
+    const endpoint = resolveEndpoint(RESET_PASSWORD_ENDPOINT, input.endpoint);
+    const payload = {
+        email: input.email.toLowerCase().trim(),
+    };
+    const clientRequest = (0, base_client_1.getClientRequest)(options.client);
+    if (clientRequest) {
+        const headers = (0, base_client_1.buildHeaders)(options);
+        const raw = await clientRequest(endpoint, {
+            method: "POST",
+            body: JSON.stringify(payload),
+            headers,
+        });
+        // Accept empty object {} as valid response (API returns {} for security)
+        if (raw === null || (typeof raw !== "object" && raw !== undefined)) {
+            throw new Error("Invalid response from password reset endpoint");
+        }
+        // Return empty object or the response as-is
+        return (raw || {});
+    }
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("No fetch implementation available. Provide `fetchImpl` or a Medusa client.");
+    }
+    const url = `${(0, base_client_1.normalizeBaseUrl)(options.baseUrl)}${endpoint}`;
+    const headers = (0, base_client_1.buildHeaders)(options);
+    const response = await fetchImpl(url || endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(body || `Failed to request password reset (status ${response.status})`);
+    }
+    // Handle empty response (204 No Content) or empty JSON object
+    const contentType = response.headers.get("content-type");
+    if (contentType && contentType.includes("application/json")) {
+        const json = await response.json();
+        // Accept empty object {} as valid response
+        return (json || {});
+    }
+    // If no content, return empty object
+    return {};
+};
+exports.requestPasswordReset = requestPasswordReset;
+/**
+ * Complete a password reset with a new password
+ *
+ * This function calls the password reset completion endpoint which validates
+ * the reset token and updates the customer's password using Medusa's AUTH module
+ * `updateProvider` method.
+ *
+ * The token is sent in both:
+ * - The request body (`token` field)
+ * - The `Authorization: Bearer {token}` header (automatically added)
+ *
+ * The route reads the token from the Authorization header and passes it to
+ * `updateProvider`, which handles token validation, password hashing, and database updates.
+ *
+ * @param input - Password reset completion input
+ * @param options - Transport options (baseUrl, client, publishableApiKey, etc.)
+ * @returns Promise resolving to the reset completion response
+ *
+ * @example
+ * ```typescript
+ * import { completePasswordReset } from "customer-registration/helpers"
+ *
+ * // Basic usage with token in input
+ * const result = await completePasswordReset(
+ *   {
+ *     email: "customer@example.com",
+ *     password: "NewSecurePassword123!",
+ *     token: "reset_token_from_email"
+ *   },
+ *   { baseUrl: "https://store.example.com", publishableApiKey: "pk_..." }
+ * )
+ *
+ * // With token in Authorization header (helper automatically adds it)
+ * const result = await completePasswordReset(
+ *   {
+ *     email: "customer@example.com",
+ *     password: "NewSecurePassword123!",
+ *     token: "reset_token_from_email"
+ *   },
+ *   {
+ *     baseUrl: "https://store.example.com",
+ *     publishableApiKey: "pk_...",
+ *     headers: {
+ *       "Authorization": "Bearer reset_token_from_email"
+ *     }
+ *   }
+ * )
+ *
+ * // With Medusa SDK client
+ * import { sdk } from "@medusajs/js-sdk"
+ * const result = await completePasswordReset(
+ *   {
+ *     email: "customer@example.com",
+ *     password: "NewSecurePassword123!",
+ *     token: "reset_token_from_email"
+ *   },
+ *   { client: sdk }
+ * )
+ * ```
+ */
+const completePasswordReset = async (input, options = {}) => {
+    const endpoint = resolveEndpoint(COMPLETE_PASSWORD_RESET_ENDPOINT, input.endpoint);
+    const payload = {
+        email: input.email.toLowerCase().trim(),
+        password: input.password,
+        token: input.token,
+    };
+    const clientRequest = (0, base_client_1.getClientRequest)(options.client);
+    if (clientRequest) {
+        const headers = (0, base_client_1.buildHeaders)(options);
+        // Add Authorization header if token is provided and not already in headers
+        if (input.token && !headers.authorization) {
+            headers.authorization = `Bearer ${input.token}`;
+        }
+        const raw = await clientRequest(endpoint, {
+            method: "POST",
+            body: JSON.stringify(payload),
+            headers,
+        });
+        if (!raw || typeof raw !== "object" || !("success" in raw)) {
+            throw new Error("Invalid response from password reset completion endpoint");
+        }
+        return raw;
+    }
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("No fetch implementation available. Provide `fetchImpl` or a Medusa client.");
+    }
+    const url = `${(0, base_client_1.normalizeBaseUrl)(options.baseUrl)}${endpoint}`;
+    const headers = (0, base_client_1.buildHeaders)(options);
+    // Add Authorization header if token is provided and not already in headers
+    if (input.token && !headers.authorization) {
+        headers.authorization = `Bearer ${input.token}`;
+    }
+    const response = await fetchImpl(url || endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(body || `Failed to complete password reset (status ${response.status})`);
+    }
+    const json = await response.json();
+    if (!json || typeof json !== "object" || !("success" in json)) {
+        throw new Error("Invalid response format from password reset completion endpoint");
+    }
+    return json;
+};
+exports.completePasswordReset = completePasswordReset;
+/**
+ * Factory creator for preconfigured password reset request helper
+ */
+const createRequestPasswordReset = (options = {}) => (input) => (0, exports.requestPasswordReset)(input, options);
+exports.createRequestPasswordReset = createRequestPasswordReset;
+/**
+ * Factory creator for preconfigured password reset completion helper
+ */
+const createCompletePasswordReset = (options = {}) => (input) => (0, exports.completePasswordReset)(input, options);
+exports.createCompletePasswordReset = createCompletePasswordReset;
+//# sourceMappingURL=data:application/json;base64,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