customer-registration 0.0.22 → 0.0.23

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const utils_1 = require("@medusajs/framework/utils");
+const customer_registration_1 = require("../../../../../../modules/customer-registration");
+async function POST(req, res) {
+    const { email, customer_id, code } = req.body;
+    if (!code || (!email && !customer_id)) {
+        res.status(400).json({
+            message: "Both code and either email or customer_id are required.",
+            type: "invalid_data",
+        });
+        return;
+    }
+    const customerRegistrationService = req.scope.resolve(customer_registration_1.CUSTOMER_REGISTRATION_MODULE);
+    try {
+        const customer = await customerRegistrationService.verifyEmailOtp({
+            customerId: customer_id,
+            email,
+            code,
+        });
+        res.status(200).json({ customer });
+    }
+    catch (error) {
+        if (utils_1.MedusaError.isMedusaError?.(error)) {
+            res.status(mapMedusaErrorToStatus(error.type)).json({
+                message: error.message,
+                type: error.type,
+            });
+            return;
+        }
+        res.status(500).json({
+            message: error?.message ?? "Failed to verify email OTP",
+            type: "unknown_error",
+        });
+    }
+}
+const mapMedusaErrorToStatus = (type) => {
+    switch (type) {
+        case utils_1.MedusaError.Types.NOT_FOUND:
+            return 404;
+        case utils_1.MedusaError.Types.NOT_ALLOWED:
+        case utils_1.MedusaError.Types.INVALID_DATA:
+            return 400;
+        default:
+            return 500;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL3N0b3JlL2N1c3RvbWVycy9lbWFpbC9vdHAvdmVyaWZ5L3JvdXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBYUEsb0JBcUNDO0FBakRELHFEQUF1RDtBQUN2RCwyRkFFd0Q7QUFTakQsS0FBSyxVQUFVLElBQUksQ0FBQyxHQUFrQixFQUFFLEdBQW1CO0lBQ2hFLE1BQU0sRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSxHQUFHLEdBQUcsQ0FBQyxJQUEwQixDQUFBO0lBRW5FLElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLEtBQUssSUFBSSxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUM7UUFDdEMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUM7WUFDbkIsT0FBTyxFQUFFLHlEQUF5RDtZQUNsRSxJQUFJLEVBQUUsY0FBYztTQUNyQixDQUFDLENBQUE7UUFDRixPQUFNO0lBQ1IsQ0FBQztJQUVELE1BQU0sMkJBQTJCLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQ25ELG9EQUE0QixDQUNRLENBQUE7SUFFdEMsSUFBSSxDQUFDO1FBQ0gsTUFBTSxRQUFRLEdBQUcsTUFBTSwyQkFBMkIsQ0FBQyxjQUFjLENBQUM7WUFDaEUsVUFBVSxFQUFFLFdBQVc7WUFDdkIsS0FBSztZQUNMLElBQUk7U0FDTCxDQUFDLENBQUE7UUFFRixHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUE7SUFDcEMsQ0FBQztJQUFDLE9BQU8sS0FBVSxFQUFFLENBQUM7UUFDcEIsSUFBSSxtQkFBVyxDQUFDLGFBQWEsRUFBRSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDdkMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7Z0JBQ2xELE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTztnQkFDdEIsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJO2FBQ2pCLENBQUMsQ0FBQTtZQUNGLE9BQU07UUFDUixDQUFDO1FBRUQsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUM7WUFDbkIsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLElBQUksNEJBQTRCO1lBQ3ZELElBQUksRUFBRSxlQUFlO1NBQ3RCLENBQUMsQ0FBQTtJQUNKLENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLElBQVksRUFBRSxFQUFFO0lBQzlDLFFBQVEsSUFBSSxFQUFFLENBQUM7UUFDYixLQUFLLG1CQUFXLENBQUMsS0FBSyxDQUFDLFNBQVM7WUFDOUIsT0FBTyxHQUFHLENBQUE7UUFDWixLQUFLLG1CQUFXLENBQUMsS0FBSyxDQUFDLFdBQVcsQ0FBQztRQUNuQyxLQUFLLG1CQUFXLENBQUMsS0FBSyxDQUFDLFlBQVk7WUFDakMsT0FBTyxHQUFHLENBQUE7UUFDWjtZQUNFLE9BQU8sR0FBRyxDQUFBO0lBQ2QsQ0FBQztBQUNILENBQUMsQ0FBQSJ9

package/.medusa/server/src/api/store/customers/phone/otp/send/route.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const utils_1 = require("@medusajs/framework/utils");
+const customer_registration_1 = require("../../../../../../modules/customer-registration");
+async function POST(req, res) {
+    const { customer_id, email } = req.body;
+    if (!customer_id && !email) {
+        res.status(400).json({
+            message: "Either customer_id or email is required to send a phone OTP.",
+            type: "invalid_data",
+        });
+        return;
+    }
+    const customerRegistrationService = req.scope.resolve(customer_registration_1.CUSTOMER_REGISTRATION_MODULE);
+    try {
+        await customerRegistrationService.sendPhoneOtp({
+            customerId: customer_id,
+            email,
+        });
+        res.status(200).json({ sent: true });
+    }
+    catch (error) {
+        if (utils_1.MedusaError.isMedusaError?.(error)) {
+            res.status(mapMedusaErrorToStatus(error.type)).json({
+                message: error.message,
+                type: error.type,
+            });
+            return;
+        }
+        res.status(500).json({
+            message: error?.message ?? "Failed to send phone OTP",
+            type: "unknown_error",
+        });
+    }
+}
+const mapMedusaErrorToStatus = (type) => {
+    switch (type) {
+        case utils_1.MedusaError.Types.NOT_FOUND:
+            return 404;
+        case utils_1.MedusaError.Types.NOT_ALLOWED:
+        case utils_1.MedusaError.Types.INVALID_DATA:
+            return 400;
+        default:
+            return 500;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL3N0b3JlL2N1c3RvbWVycy9waG9uZS9vdHAvc2VuZC9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVlBLG9CQW9DQztBQS9DRCxxREFBdUQ7QUFDdkQsMkZBRXdEO0FBUWpELEtBQUssVUFBVSxJQUFJLENBQUMsR0FBa0IsRUFBRSxHQUFtQjtJQUNoRSxNQUFNLEVBQUUsV0FBVyxFQUFFLEtBQUssRUFBRSxHQUFHLEdBQUcsQ0FBQyxJQUF3QixDQUFBO0lBRTNELElBQUksQ0FBQyxXQUFXLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMzQixHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztZQUNuQixPQUFPLEVBQUUsOERBQThEO1lBQ3ZFLElBQUksRUFBRSxjQUFjO1NBQ3JCLENBQUMsQ0FBQTtRQUNGLE9BQU07SUFDUixDQUFDO0lBRUQsTUFBTSwyQkFBMkIsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FDbkQsb0RBQTRCLENBQ1EsQ0FBQTtJQUV0QyxJQUFJLENBQUM7UUFDSCxNQUFNLDJCQUEyQixDQUFDLFlBQVksQ0FBQztZQUM3QyxVQUFVLEVBQUUsV0FBVztZQUN2QixLQUFLO1NBQ04sQ0FBQyxDQUFBO1FBRUYsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtJQUN0QyxDQUFDO0lBQUMsT0FBTyxLQUFVLEVBQUUsQ0FBQztRQUNwQixJQUFJLG1CQUFXLENBQUMsYUFBYSxFQUFFLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN2QyxHQUFHLENBQUMsTUFBTSxDQUFDLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztnQkFDbEQsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO2dCQUN0QixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7YUFDakIsQ0FBQyxDQUFBO1lBQ0YsT0FBTTtRQUNSLENBQUM7UUFFRCxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztZQUNuQixPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sSUFBSSwwQkFBMEI7WUFDckQsSUFBSSxFQUFFLGVBQWU7U0FDdEIsQ0FBQyxDQUFBO0lBQ0osQ0FBQztBQUNILENBQUM7QUFFRCxNQUFNLHNCQUFzQixHQUFHLENBQUMsSUFBWSxFQUFFLEVBQUU7SUFDOUMsUUFBUSxJQUFJLEVBQUUsQ0FBQztRQUNiLEtBQUssbUJBQVcsQ0FBQyxLQUFLLENBQUMsU0FBUztZQUM5QixPQUFPLEdBQUcsQ0FBQTtRQUNaLEtBQUssbUJBQVcsQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDO1FBQ25DLEtBQUssbUJBQVcsQ0FBQyxLQUFLLENBQUMsWUFBWTtZQUNqQyxPQUFPLEdBQUcsQ0FBQTtRQUNaO1lBQ0UsT0FBTyxHQUFHLENBQUE7SUFDZCxDQUFDO0FBQ0gsQ0FBQyxDQUFBIn0=

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const utils_1 = require("@medusajs/framework/utils");
+const customer_registration_1 = require("../../../../../../modules/customer-registration");
+async function POST(req, res) {
+    const { customer_id, email, code } = req.body;
+    if (!code || (!customer_id && !email)) {
+        res.status(400).json({
+            message: "Both code and either customer_id or email are required.",
+            type: "invalid_data",
+        });
+        return;
+    }
+    const customerRegistrationService = req.scope.resolve(customer_registration_1.CUSTOMER_REGISTRATION_MODULE);
+    try {
+        const customer = await customerRegistrationService.verifyPhoneOtp({
+            customerId: customer_id,
+            email,
+            code,
+        });
+        res.status(200).json({ customer });
+    }
+    catch (error) {
+        if (utils_1.MedusaError.isMedusaError?.(error)) {
+            res.status(mapMedusaErrorToStatus(error.type)).json({
+                message: error.message,
+                type: error.type,
+            });
+            return;
+        }
+        res.status(500).json({
+            message: error?.message ?? "Failed to verify phone OTP",
+            type: "unknown_error",
+        });
+    }
+}
+const mapMedusaErrorToStatus = (type) => {
+    switch (type) {
+        case utils_1.MedusaError.Types.NOT_FOUND:
+            return 404;
+        case utils_1.MedusaError.Types.NOT_ALLOWED:
+        case utils_1.MedusaError.Types.INVALID_DATA:
+            return 400;
+        default:
+            return 500;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL3N0b3JlL2N1c3RvbWVycy9waG9uZS9vdHAvdmVyaWZ5L3JvdXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBYUEsb0JBcUNDO0FBakRELHFEQUF1RDtBQUN2RCwyRkFFd0Q7QUFTakQsS0FBSyxVQUFVLElBQUksQ0FBQyxHQUFrQixFQUFFLEdBQW1CO0lBQ2hFLE1BQU0sRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxHQUFHLEdBQUcsQ0FBQyxJQUEwQixDQUFBO0lBRW5FLElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLFdBQVcsSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDdEMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUM7WUFDbkIsT0FBTyxFQUFFLHlEQUF5RDtZQUNsRSxJQUFJLEVBQUUsY0FBYztTQUNyQixDQUFDLENBQUE7UUFDRixPQUFNO0lBQ1IsQ0FBQztJQUVELE1BQU0sMkJBQTJCLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQ25ELG9EQUE0QixDQUNRLENBQUE7SUFFdEMsSUFBSSxDQUFDO1FBQ0gsTUFBTSxRQUFRLEdBQUcsTUFBTSwyQkFBMkIsQ0FBQyxjQUFjLENBQUM7WUFDaEUsVUFBVSxFQUFFLFdBQVc7WUFDdkIsS0FBSztZQUNMLElBQUk7U0FDTCxDQUFDLENBQUE7UUFFRixHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUE7SUFDcEMsQ0FBQztJQUFDLE9BQU8sS0FBVSxFQUFFLENBQUM7UUFDcEIsSUFBSSxtQkFBVyxDQUFDLGFBQWEsRUFBRSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDdkMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7Z0JBQ2xELE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTztnQkFDdEIsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJO2FBQ2pCLENBQUMsQ0FBQTtZQUNGLE9BQU07UUFDUixDQUFDO1FBRUQsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUM7WUFDbkIsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLElBQUksNEJBQTRCO1lBQ3ZELElBQUksRUFBRSxlQUFlO1NBQ3RCLENBQUMsQ0FBQTtJQUNKLENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLElBQVksRUFBRSxFQUFFO0lBQzlDLFFBQVEsSUFBSSxFQUFFLENBQUM7UUFDYixLQUFLLG1CQUFXLENBQUMsS0FBSyxDQUFDLFNBQVM7WUFDOUIsT0FBTyxHQUFHLENBQUE7UUFDWixLQUFLLG1CQUFXLENBQUMsS0FBSyxDQUFDLFdBQVcsQ0FBQztRQUNuQyxLQUFLLG1CQUFXLENBQUMsS0FBSyxDQUFDLFlBQVk7WUFDakMsT0FBTyxHQUFHLENBQUE7UUFDWjtZQUNFLE9BQU8sR0FBRyxDQUFBO0lBQ2QsQ0FBQztBQUNILENBQUMsQ0FBQSJ9

package/.medusa/server/src/api/store/customers/route.js

@@ -2,8 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.POST = POST;
 const utils_1 = require("@medusajs/framework/utils");
+const customer_registration_1 = require("../../../modules/customer-registration");
+const constants_1 = require("../../../modules/customer-registration/constants");
 async function POST(req, res) {
     const customerModuleService = req.scope.resolve(utils_1.Modules.CUSTOMER);
+    const customerRegistrationService = req.scope.resolve(customer_registration_1.CUSTOMER_REGISTRATION_MODULE);
+    const registrationOptions = req.scope.resolve(constants_1.CUSTOMER_REGISTRATION_OPTIONS_KEY);
     const body = req.body;
     try {
         // Extract customer data from request body
@@ -24,6 +28,9 @@ async function POST(req, res) {
         // createCustomers expects an array
         const customers = await customerModuleService.createCustomers([customerData]);
         const customer = customers[0];
+        if (registrationOptions?.email?.autoSendOnRegistration) {
+            await customerRegistrationService.sendEmailOtp({ customerId: customer.id });
+        }
         // Retrieve the created customer to return
         const createdCustomer = await customerModuleService.retrieveCustomer(customer.id);
         // Return the customer in the expected format
@@ -32,19 +39,39 @@ async function POST(req, res) {
         });
     }
     catch (error) {
-        // Handle errors appropriately
+        if (utils_1.MedusaError.isMedusaError?.(error)) {
+            res.status(mapMedusaErrorToStatus(error.type)).json({
+                message: error.message,
+                type: error.type,
+            });
+            return;
+        }
         if (error.message?.includes("already exists") || error.message?.includes("duplicate")) {
             res.status(409).json({
                 message: "A customer with this email already exists",
                 type: "duplicate_error",
             });
+            return;
         }
-        else {
-            res.status(400).json({
-                message: error.message || "Failed to create customer",
-                type: "invalid_data",
-            });
-        }
+        res.status(400).json({
+            message: error.message || "Failed to create customer",
+            type: "invalid_data",
+        });
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL3N0b3JlL2N1c3RvbWVycy9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQW1CQSxvQkE0REM7QUE3RUQscURBQW1EO0FBaUI1QyxLQUFLLFVBQVUsSUFBSSxDQUN4QixHQUFrQixFQUNsQixHQUFtQjtJQUVuQixNQUFNLHFCQUFxQixHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGVBQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUNqRSxNQUFNLElBQUksR0FBRyxHQUFHLENBQUMsSUFBaUMsQ0FBQTtJQUVsRCxJQUFJLENBQUM7UUFDSCwwQ0FBMEM7UUFDMUMsTUFBTSxFQUNKLEtBQUssRUFDTCxVQUFVLEVBQ1YsU0FBUyxFQUNULEtBQUssRUFDTCxZQUFZLEVBQ1osUUFBUSxFQUNSLGNBQWMsRUFBRSxzQkFBc0IsRUFDdEMsY0FBYyxFQUFFLHNCQUFzQixFQUN0QyxHQUFHLElBQUksRUFDUixHQUFHLElBQUksQ0FBQTtRQUVSLDREQUE0RDtRQUM1RCxNQUFNLFlBQVksR0FBOEI7WUFDOUMsR0FBRyxJQUFJO1lBQ1AsS0FBSztZQUNMLFVBQVU7WUFDVixTQUFTO1lBQ1QsS0FBSztZQUNMLFlBQVk7WUFDWixRQUFRLEVBQUUsUUFBUSxJQUFJLEVBQUU7WUFDeEIsY0FBYyxFQUFFLEtBQUs7WUFDckIsY0FBYyxFQUFFLEtBQUs7U0FDdEIsQ0FBQTtRQUVELHdEQUF3RDtRQUN4RCxtQ0FBbUM7UUFDbkMsTUFBTSxTQUFTLEdBQUcsTUFBTSxxQkFBcUIsQ0FBQyxlQUFlLENBQUMsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFBO1FBQzdFLE1BQU0sUUFBUSxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUU3QiwwQ0FBMEM7UUFDMUMsTUFBTSxlQUFlLEdBQUcsTUFBTSxxQkFBcUIsQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUE4QixDQUFBO1FBRTlHLDZDQUE2QztRQUM3QyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztZQUNuQixRQUFRLEVBQUUsZUFBZTtTQUMxQixDQUFDLENBQUE7SUFDSixDQUFDO0lBQUMsT0FBTyxLQUFVLEVBQUUsQ0FBQztRQUNwQiw4QkFBOEI7UUFDOUIsSUFBSSxLQUFLLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLEtBQUssQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUM7WUFDdEYsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUM7Z0JBQ25CLE9BQU8sRUFBRSwyQ0FBMkM7Z0JBQ3BELElBQUksRUFBRSxpQkFBaUI7YUFDeEIsQ0FBQyxDQUFBO1FBQ0osQ0FBQzthQUFNLENBQUM7WUFDTixHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztnQkFDbkIsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPLElBQUksMkJBQTJCO2dCQUNyRCxJQUFJLEVBQUUsY0FBYzthQUNyQixDQUFDLENBQUE7UUFDSixDQUFDO0lBQ0gsQ0FBQztBQUNILENBQUMifQ==
+const mapMedusaErrorToStatus = (type) => {
+    switch (type) {
+        case utils_1.MedusaError.Types.NOT_ALLOWED:
+        case utils_1.MedusaError.Types.INVALID_DATA:
+            return 400;
+        case utils_1.MedusaError.Types.NOT_FOUND:
+            return 404;
+        case utils_1.MedusaError.Types.UNAUTHORIZED:
+            return 401;
+        case utils_1.MedusaError.Types.DUPLICATE_ERROR:
+            return 409;
+        default:
+            return 500;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL3N0b3JlL2N1c3RvbWVycy9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQXlCQSxvQkE4RUM7QUFyR0QscURBQWdFO0FBRWhFLGtGQUUrQztBQUMvQyxnRkFBb0c7QUFrQjdGLEtBQUssVUFBVSxJQUFJLENBQ3hCLEdBQWtCLEVBQ2xCLEdBQW1CO0lBRW5CLE1BQU0scUJBQXFCLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsZUFBTyxDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQ2pFLE1BQU0sMkJBQTJCLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQ25ELG9EQUE0QixDQUNRLENBQUE7SUFDdEMsTUFBTSxtQkFBbUIsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FDM0MsNkNBQWlDLENBQ0ssQ0FBQTtJQUN4QyxNQUFNLElBQUksR0FBRyxHQUFHLENBQUMsSUFBaUMsQ0FBQTtJQUVsRCxJQUFJLENBQUM7UUFDSCwwQ0FBMEM7UUFDMUMsTUFBTSxFQUNKLEtBQUssRUFDTCxVQUFVLEVBQ1YsU0FBUyxFQUNULEtBQUssRUFDTCxZQUFZLEVBQ1osUUFBUSxFQUNSLGNBQWMsRUFBRSxzQkFBc0IsRUFDdEMsY0FBYyxFQUFFLHNCQUFzQixFQUN0QyxHQUFHLElBQUksRUFDUixHQUFHLElBQUksQ0FBQTtRQUVSLDREQUE0RDtRQUM1RCxNQUFNLFlBQVksR0FBOEI7WUFDOUMsR0FBRyxJQUFJO1lBQ1AsS0FBSztZQUNMLFVBQVU7WUFDVixTQUFTO1lBQ1QsS0FBSztZQUNMLFlBQVk7WUFDWixRQUFRLEVBQUUsUUFBUSxJQUFJLEVBQUU7WUFDeEIsY0FBYyxFQUFFLEtBQUs7WUFDckIsY0FBYyxFQUFFLEtBQUs7U0FDdEIsQ0FBQTtRQUVELHdEQUF3RDtRQUN4RCxtQ0FBbUM7UUFDbkMsTUFBTSxTQUFTLEdBQUcsTUFBTSxxQkFBcUIsQ0FBQyxlQUFlLENBQUMsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFBO1FBQzdFLE1BQU0sUUFBUSxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUU3QixJQUFJLG1CQUFtQixFQUFFLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxDQUFDO1lBQ3ZELE1BQU0sMkJBQTJCLENBQUMsWUFBWSxDQUFDLEVBQUUsVUFBVSxFQUFFLFFBQVEsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBQzdFLENBQUM7UUFFRCwwQ0FBMEM7UUFDMUMsTUFBTSxlQUFlLEdBQUcsTUFBTSxxQkFBcUIsQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUE4QixDQUFBO1FBRTlHLDZDQUE2QztRQUM3QyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztZQUNuQixRQUFRLEVBQUUsZUFBZTtTQUMxQixDQUFDLENBQUE7SUFDSixDQUFDO0lBQUMsT0FBTyxLQUFVLEVBQUUsQ0FBQztRQUNwQixJQUFJLG1CQUFXLENBQUMsYUFBYSxFQUFFLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN2QyxHQUFHLENBQUMsTUFBTSxDQUFDLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztnQkFDbEQsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO2dCQUN0QixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7YUFDakIsQ0FBQyxDQUFBO1lBQ0YsT0FBTTtRQUNSLENBQUM7UUFFRCxJQUFJLEtBQUssQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLGdCQUFnQixDQUFDLElBQUksS0FBSyxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQztZQUN0RixHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQztnQkFDbkIsT0FBTyxFQUFFLDJDQUEyQztnQkFDcEQsSUFBSSxFQUFFLGlCQUFpQjthQUN4QixDQUFDLENBQUE7WUFDRixPQUFNO1FBQ1IsQ0FBQztRQUVELEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDO1lBQ25CLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTyxJQUFJLDJCQUEyQjtZQUNyRCxJQUFJLEVBQUUsY0FBYztTQUNyQixDQUFDLENBQUE7SUFDSixDQUFDO0FBQ0gsQ0FBQztBQUVELE1BQU0sc0JBQXNCLEdBQUcsQ0FBQyxJQUFZLEVBQUUsRUFBRTtJQUM5QyxRQUFRLElBQUksRUFBRSxDQUFDO1FBQ2IsS0FBSyxtQkFBVyxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUM7UUFDbkMsS0FBSyxtQkFBVyxDQUFDLEtBQUssQ0FBQyxZQUFZO1lBQ2pDLE9BQU8sR0FBRyxDQUFBO1FBQ1osS0FBSyxtQkFBVyxDQUFDLEtBQUssQ0FBQyxTQUFTO1lBQzlCLE9BQU8sR0FBRyxDQUFBO1FBQ1osS0FBSyxtQkFBVyxDQUFDLEtBQUssQ0FBQyxZQUFZO1lBQ2pDLE9BQU8sR0FBRyxDQUFBO1FBQ1osS0FBSyxtQkFBVyxDQUFDLEtBQUssQ0FBQyxlQUFlO1lBQ3BDLE9BQU8sR0FBRyxDQUFBO1FBQ1o7WUFDRSxPQUFPLEdBQUcsQ0FBQTtJQUNkLENBQUM7QUFDSCxDQUFDLENBQUEifQ==

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const awilix_1 = require("@medusajs/framework/awilix");
+const constants_1 = require("../modules/customer-registration/constants");
+const config_1 = require("../modules/customer-registration/config");
+exports.default = async ({ container, options }) => {
+    const resolvedOptions = (0, config_1.buildCustomerRegistrationOptions)((options ?? {}));
+    container.register({
+        [constants_1.CUSTOMER_REGISTRATION_OPTIONS_KEY]: (0, awilix_1.asValue)(resolvedOptions),
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbG9hZGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHVEQUFvRDtBQUVwRCwwRUFBOEY7QUFDOUYsb0VBQTBGO0FBRzFGLGtCQUFlLEtBQUssRUFBRSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQWlCLEVBQUUsRUFBRTtJQUM3RCxNQUFNLGVBQWUsR0FBRyxJQUFBLHlDQUFnQyxFQUN0RCxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQXNDLENBQ3JELENBQUE7SUFFRCxTQUFTLENBQUMsUUFBUSxDQUFDO1FBQ2pCLENBQUMsNkNBQWlDLENBQUMsRUFBRSxJQUFBLGdCQUFPLEVBQUMsZUFBZSxDQUFDO0tBQzlELENBQUMsQ0FBQTtBQUNKLENBQUMsQ0FBQSJ9

package/.medusa/server/src/modules/customer-registration/__tests__/config.spec.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const config_1 = require("../config");
+const cases = [
+    {
+        name: "defaults kick in when no options provided",
+        assertions: (result) => {
+            (0, vitest_1.expect)(result.otpLength).toBe(6);
+            (0, vitest_1.expect)(result.email.channel).toBe("email");
+            (0, vitest_1.expect)(result.phone.channel).toBe("sms");
+        },
+    },
+    {
+        name: "otp config respects overrides with validation",
+        input: {
+            otpLength: 8,
+            otpCharset: "alphanumeric",
+            otpExpiryMinutes: 20,
+            maxAttempts: 7,
+        },
+        assertions: (result) => {
+            (0, vitest_1.expect)(result.otpLength).toBe(8);
+            (0, vitest_1.expect)(result.otpCharset).toBe("alphanumeric");
+            (0, vitest_1.expect)(result.otpExpiryMinutes).toBe(20);
+            (0, vitest_1.expect)(result.maxAttempts).toBe(7);
+        },
+    },
+    {
+        name: "channel overrides merge deeply",
+        input: {
+            email: {
+                channel: "custom-email",
+                subject: "Custom Subject",
+                resendThrottleSeconds: 120,
+                autoSendOnRegistration: false,
+            },
+            phone: {
+                channel: "custom-sms",
+                template: "otp-sms",
+            },
+        },
+        assertions: (result) => {
+            (0, vitest_1.expect)(result.email.channel).toBe("custom-email");
+            (0, vitest_1.expect)(result.email.subject).toBe("Custom Subject");
+            (0, vitest_1.expect)(result.email.autoSendOnRegistration).toBe(false);
+            (0, vitest_1.expect)(result.email.resendThrottleSeconds).toBe(120);
+            (0, vitest_1.expect)(result.phone.channel).toBe("custom-sms");
+            (0, vitest_1.expect)(result.phone.template).toBe("otp-sms");
+        },
+    },
+];
+(0, vitest_1.describe)("buildCustomerRegistrationOptions", () => {
+    cases.forEach(({ name, input, assertions }) => {
+        (0, vitest_1.it)(name, () => {
+            const result = (0, config_1.buildCustomerRegistrationOptions)(input);
+            assertions(result);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/customer-registration/config.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCustomerRegistrationOptions = exports.CUSTOMER_REGISTRATION_DEFAULTS = void 0;
+const EMAIL_DEFAULTS = {
+    channel: "email",
+    template: null,
+    resendThrottleSeconds: 60,
+    autoSendOnRegistration: true,
+    subject: "Verify your email",
+};
+const PHONE_DEFAULTS = {
+    channel: "sms",
+    template: null,
+    resendThrottleSeconds: 60,
+};
+exports.CUSTOMER_REGISTRATION_DEFAULTS = {
+    otpLength: 6,
+    otpCharset: "numeric",
+    otpExpiryMinutes: 10,
+    maxAttempts: 5,
+    email: EMAIL_DEFAULTS,
+    phone: PHONE_DEFAULTS,
+};
+const NUMERIC_CHARSET = "numeric";
+const ALPHANUMERIC_CHARSET = "alphanumeric";
+const sanitizeCharset = (value) => {
+    if (!value) {
+        return NUMERIC_CHARSET;
+    }
+    const normalized = value.toLowerCase();
+    return normalized === ALPHANUMERIC_CHARSET ? ALPHANUMERIC_CHARSET : NUMERIC_CHARSET;
+};
+const withPositiveNumber = (maybeValue, fallback, options) => {
+    const parsed = Number(maybeValue);
+    if (Number.isFinite(parsed) && parsed >= (options?.min ?? 1)) {
+        return parsed;
+    }
+    return fallback;
+};
+const mergeEmailOptions = (user) => {
+    return {
+        ...EMAIL_DEFAULTS,
+        ...user,
+        channel: user?.channel ?? EMAIL_DEFAULTS.channel,
+        template: user?.template ?? EMAIL_DEFAULTS.template,
+        resendThrottleSeconds: withPositiveNumber(user?.resendThrottleSeconds, EMAIL_DEFAULTS.resendThrottleSeconds),
+        autoSendOnRegistration: user?.autoSendOnRegistration ?? EMAIL_DEFAULTS.autoSendOnRegistration,
+        subject: user?.subject ?? EMAIL_DEFAULTS.subject,
+    };
+};
+const mergePhoneOptions = (user) => {
+    return {
+        ...PHONE_DEFAULTS,
+        ...user,
+        channel: user?.channel ?? PHONE_DEFAULTS.channel,
+        template: user?.template ?? PHONE_DEFAULTS.template,
+        resendThrottleSeconds: withPositiveNumber(user?.resendThrottleSeconds, PHONE_DEFAULTS.resendThrottleSeconds),
+    };
+};
+const buildCustomerRegistrationOptions = (options) => {
+    const email = mergeEmailOptions(options?.email);
+    const phone = mergePhoneOptions(options?.phone);
+    return {
+        otpLength: withPositiveNumber(options?.otpLength, exports.CUSTOMER_REGISTRATION_DEFAULTS.otpLength),
+        otpCharset: sanitizeCharset(options?.otpCharset),
+        otpExpiryMinutes: withPositiveNumber(options?.otpExpiryMinutes, exports.CUSTOMER_REGISTRATION_DEFAULTS.otpExpiryMinutes),
+        maxAttempts: withPositiveNumber(options?.maxAttempts, exports.CUSTOMER_REGISTRATION_DEFAULTS.maxAttempts),
+        email,
+        phone,
+    };
+};
+exports.buildCustomerRegistrationOptions = buildCustomerRegistrationOptions;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/customer-registration/constants.js

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

package/.medusa/server/src/modules/customer-registration/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOMER_REGISTRATION_MODULE = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const service_1 = __importDefault(require("./service"));
+exports.CUSTOMER_REGISTRATION_MODULE = "customer-registration";
+exports.default = (0, utils_1.Module)(exports.CUSTOMER_REGISTRATION_MODULE, {
+    service: service_1.default,
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9jdXN0b21lci1yZWdpc3RyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEscURBQWtEO0FBQ2xELHdEQUF5RDtBQUU1QyxRQUFBLDRCQUE0QixHQUFHLHVCQUF1QixDQUFBO0FBRW5FLGtCQUFlLElBQUEsY0FBTSxFQUFDLG9DQUE0QixFQUFFO0lBQ2xELE9BQU8sRUFBRSxpQkFBaUM7Q0FDM0MsQ0FBQyxDQUFBIn0=

package/.medusa/server/src/modules/customer-registration/migrations/Migration20250118001000CreateCustomerOtpTable.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20250118001000 = void 0;
+const migrations_1 = require("@medusajs/framework/mikro-orm/migrations");
+const TABLE_NAME = "customer_registration_otp";
+class Migration20250118001000 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`
+      create table if not exists "${TABLE_NAME}" (
+        "id" text not null,
+        "customer_id" text not null,
+        "type" text not null,
+        "code_hash" text not null,
+        "delivery_target" text not null,
+        "channel" text not null,
+        "attempt_count" integer not null default 0,
+        "expires_at" timestamptz not null,
+        "consumed_at" timestamptz null,
+        "metadata" jsonb null,
+        "created_at" timestamptz not null default now(),
+        "updated_at" timestamptz not null default now(),
+        "deleted_at" timestamptz null,
+        constraint "${TABLE_NAME}_pkey" primary key ("id"),
+        constraint "${TABLE_NAME}_customer_id_foreign" foreign key ("customer_id") references "customer" ("id") on delete cascade
+      );
+    `);
+        this.addSql(`
+      create index if not exists "customer_registration_otp_customer_type_idx"
+      on "${TABLE_NAME}" ("customer_id", "type")
+      where "deleted_at" is null;
+    `);
+        this.addSql(`
+      create index if not exists "customer_registration_otp_expires_idx"
+      on "${TABLE_NAME}" ("expires_at")
+      where "deleted_at" is null;
+    `);
+        this.addSql(`
+      create index if not exists "customer_registration_otp_consumed_idx"
+      on "${TABLE_NAME}" ("consumed_at")
+      where "deleted_at" is null;
+    `);
+    }
+    async down() {
+        this.addSql(`drop table if exists "${TABLE_NAME}";`);
+    }
+}
+exports.Migration20250118001000 = Migration20250118001000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNTAxMTgwMDEwMDBDcmVhdGVDdXN0b21lck90cFRhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvY3VzdG9tZXItcmVnaXN0cmF0aW9uL21pZ3JhdGlvbnMvTWlncmF0aW9uMjAyNTAxMTgwMDEwMDBDcmVhdGVDdXN0b21lck90cFRhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHlFQUFvRTtBQUVwRSxNQUFNLFVBQVUsR0FBRywyQkFBMkIsQ0FBQTtBQUU5QyxNQUFhLHVCQUF3QixTQUFRLHNCQUFTO0lBQ3BELEtBQUssQ0FBQyxFQUFFO1FBQ04sSUFBSSxDQUFDLE1BQU0sQ0FBQztvQ0FDb0IsVUFBVTs7Ozs7Ozs7Ozs7Ozs7c0JBY3hCLFVBQVU7c0JBQ1YsVUFBVTs7S0FFM0IsQ0FBQyxDQUFBO1FBRUYsSUFBSSxDQUFDLE1BQU0sQ0FBQzs7WUFFSixVQUFVOztLQUVqQixDQUFDLENBQUE7UUFFRixJQUFJLENBQUMsTUFBTSxDQUFDOztZQUVKLFVBQVU7O0tBRWpCLENBQUMsQ0FBQTtRQUVGLElBQUksQ0FBQyxNQUFNLENBQUM7O1lBRUosVUFBVTs7S0FFakIsQ0FBQyxDQUFBO0lBQ0osQ0FBQztJQUVELEtBQUssQ0FBQyxJQUFJO1FBQ1IsSUFBSSxDQUFDLE1BQU0sQ0FBQyx5QkFBeUIsVUFBVSxJQUFJLENBQUMsQ0FBQTtJQUN0RCxDQUFDO0NBQ0Y7QUE1Q0QsMERBNENDIn0=

package/.medusa/server/src/modules/customer-registration/models/customer-otp.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerOtp = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+exports.CustomerOtp = utils_1.model
+    .define("customer_registration_otp", {
+    id: utils_1.model.id({ prefix: "otp" }),
+    customer_id: utils_1.model.text(),
+    type: utils_1.model.enum(["email", "phone"]),
+    code_hash: utils_1.model.text(),
+    delivery_target: utils_1.model.text(),
+    channel: utils_1.model.text(),
+    attempt_count: utils_1.model.number().default(0),
+    expires_at: utils_1.model.dateTime(),
+    consumed_at: utils_1.model.dateTime().nullable(),
+    metadata: utils_1.model.json().nullable(),
+})
+    .indexes([
+    {
+        name: "customer_registration_otp_customer_type_idx",
+        on: ["customer_id", "type"],
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "customer_registration_otp_expires_idx",
+        on: ["expires_at"],
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "customer_registration_otp_consumed_idx",
+        on: ["consumed_at"],
+        where: "deleted_at IS NULL",
+    },
+]);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tZXItb3RwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvY3VzdG9tZXItcmVnaXN0cmF0aW9uL21vZGVscy9jdXN0b21lci1vdHAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBQWlEO0FBRXBDLFFBQUEsV0FBVyxHQUFHLGFBQUs7S0FDN0IsTUFBTSxDQUFDLDJCQUEyQixFQUFFO0lBQ25DLEVBQUUsRUFBRSxhQUFLLENBQUMsRUFBRSxDQUFDLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDO0lBQy9CLFdBQVcsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFO0lBQ3pCLElBQUksRUFBRSxhQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3BDLFNBQVMsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFO0lBQ3ZCLGVBQWUsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFO0lBQzdCLE9BQU8sRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFO0lBQ3JCLGFBQWEsRUFBRSxhQUFLLENBQUMsTUFBTSxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUN4QyxVQUFVLEVBQUUsYUFBSyxDQUFDLFFBQVEsRUFBRTtJQUM1QixXQUFXLEVBQUUsYUFBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUN4QyxRQUFRLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRSxDQUFDLFFBQVEsRUFBRTtDQUNsQyxDQUFDO0tBQ0QsT0FBTyxDQUFDO0lBQ1A7UUFDRSxJQUFJLEVBQUUsNkNBQTZDO1FBQ25ELEVBQUUsRUFBRSxDQUFDLGFBQWEsRUFBRSxNQUFNLENBQUM7UUFDM0IsS0FBSyxFQUFFLG9CQUFvQjtLQUM1QjtJQUNEO1FBQ0UsSUFBSSxFQUFFLHVDQUF1QztRQUM3QyxFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUM7UUFDbEIsS0FBSyxFQUFFLG9CQUFvQjtLQUM1QjtJQUNEO1FBQ0UsSUFBSSxFQUFFLHdDQUF3QztRQUM5QyxFQUFFLEVBQUUsQ0FBQyxhQUFhLENBQUM7UUFDbkIsS0FBSyxFQUFFLG9CQUFvQjtLQUM1QjtDQUNGLENBQUMsQ0FBQSJ9

package/.medusa/server/src/modules/customer-registration/service.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const crypto_1 = require("crypto");
+const customer_otp_1 = require("./models/customer-otp");
+const config_1 = require("./config");
+const constants_1 = require("./constants");
+const OTP_CHARSET_NUMERIC = "0123456789";
+const OTP_CHARSET_ALPHANUMERIC = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+class CustomerRegistrationModuleService extends (0, utils_1.MedusaService)({
+    CustomerOtp: customer_otp_1.CustomerOtp,
+}) {
+    constructor(container, moduleOptions, moduleDeclaration) {
+        super(container, moduleOptions, moduleDeclaration);
+        this.customerModuleService_ = container[utils_1.Modules.CUSTOMER];
+        if (!this.customerModuleService_) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Customer module is required for customer-registration plugin.");
+        }
+        this.notificationModuleService_ = container[utils_1.Modules.NOTIFICATION];
+        this.options_ =
+            container[constants_1.CUSTOMER_REGISTRATION_OPTIONS_KEY] ??
+                (0, config_1.buildCustomerRegistrationOptions)();
+    }
+    async sendEmailOtp(identifier, sharedContext) {
+        const customer = await this.resolveCustomer(identifier, sharedContext);
+        if (!customer.email) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Customer is missing an email address.");
+        }
+        await this.generateAndDispatchOtp({
+            customer,
+            purpose: "email",
+            deliveryTarget: customer.email,
+            sharedContext,
+            channelOptions: this.options_.email,
+        });
+    }
+    async sendPhoneOtp(identifier, sharedContext) {
+        const customer = await this.resolveCustomer(identifier, sharedContext);
+        if (!customer.phone) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Customer phone number is required before requesting a phone OTP.");
+        }
+        await this.generateAndDispatchOtp({
+            customer,
+            purpose: "phone",
+            deliveryTarget: customer.phone,
+            sharedContext,
+            channelOptions: this.options_.phone,
+        });
+    }
+    async verifyEmailOtp(payload, sharedContext) {
+        const customer = await this.resolveCustomer(payload, sharedContext);
+        await this.verifyOtpForCustomer({
+            customer,
+            purpose: "email",
+            code: payload.code,
+            sharedContext,
+        });
+        return await this.customerModuleService_.updateCustomers(customer.id, { email_verified: true }, sharedContext);
+    }
+    async verifyPhoneOtp(payload, sharedContext) {
+        const customer = await this.resolveCustomer(payload, sharedContext);
+        if (!customer.phone) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Customer phone number is required before verification.");
+        }
+        await this.verifyOtpForCustomer({
+            customer,
+            purpose: "phone",
+            code: payload.code,
+            sharedContext,
+        });
+        return await this.customerModuleService_.updateCustomers(customer.id, { phone_verified: true }, sharedContext);
+    }
+    async resolveCustomer(identifier, sharedContext) {
+        if (identifier.customerId) {
+            return await this.customerModuleService_.retrieveCustomer(identifier.customerId, {}, sharedContext);
+        }
+        if (identifier.email) {
+            const [customer] = await this.customerModuleService_.listCustomers({ email: identifier.email }, {}, sharedContext);
+            if (customer) {
+                return customer;
+            }
+        }
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Unable to locate customer for OTP operation.");
+    }
+    async generateAndDispatchOtp({ customer, purpose, deliveryTarget, channelOptions, sharedContext, }) {
+        await this.assertThrottleWindow(customer.id, purpose, channelOptions.resendThrottleSeconds, sharedContext);
+        await this.invalidateActiveOtps(customer.id, purpose, sharedContext);
+        const code = this.generateOtpCode();
+        const expiresAt = this.calculateExpiry();
+        const payload = {
+            customer_id: customer.id,
+            type: purpose,
+            code_hash: this.hashOtp(code),
+            delivery_target: deliveryTarget,
+            channel: channelOptions.channel,
+            expires_at: expiresAt,
+            attempt_count: 0,
+        };
+        const otpRecord = await this.createCustomerOtps(payload, sharedContext);
+        try {
+            await this.dispatchNotification({
+                customer,
+                purpose,
+                deliveryTarget,
+                code,
+                channelOptions,
+                expiresAt,
+                sharedContext,
+            });
+        }
+        catch (error) {
+            await this.deleteCustomerOtps(otpRecord.id, sharedContext);
+            throw error;
+        }
+    }
+    async verifyOtpForCustomer({ customer, purpose, code, sharedContext, }) {
+        const otp = await this.findActiveOtp(customer.id, purpose, sharedContext);
+        if (!otp) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "No OTP found. Please request a new verification code.");
+        }
+        if (otp.expires_at < new Date()) {
+            await this.consumeOtp(otp.id, sharedContext);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "OTP has expired. Please request a new verification code.");
+        }
+        if (otp.code_hash !== this.hashOtp(code)) {
+            await this.handleFailedAttempt(otp, sharedContext);
+        }
+        await this.updateCustomerOtps({
+            selector: { id: otp.id },
+            data: { consumed_at: new Date() },
+        }, sharedContext);
+    }
+    async handleFailedAttempt(otp, sharedContext) {
+        const nextAttempt = (otp.attempt_count ?? 0) + 1;
+        await this.updateCustomerOtps({
+            selector: { id: otp.id },
+            data: { attempt_count: nextAttempt },
+        }, sharedContext);
+        if (nextAttempt >= this.options_.maxAttempts) {
+            await this.consumeOtp(otp.id, sharedContext);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Maximum OTP attempts exceeded. Please request a new code.");
+        }
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Invalid OTP supplied.");
+    }
+    async findActiveOtp(customerId, purpose, sharedContext) {
+        const [otp] = await this.listCustomerOtps({
+            customer_id: customerId,
+            type: purpose,
+            consumed_at: null,
+        }, {
+            order: { created_at: "DESC" },
+            take: 1,
+        }, sharedContext);
+        return otp;
+    }
+    async consumeOtp(id, sharedContext) {
+        await this.updateCustomerOtps({
+            selector: { id },
+            data: { consumed_at: new Date() },
+        }, sharedContext);
+    }
+    async assertThrottleWindow(customerId, purpose, throttleSeconds, sharedContext) {
+        if (!throttleSeconds) {
+            return;
+        }
+        const otp = await this.findActiveOtp(customerId, purpose, sharedContext);
+        if (!otp) {
+            return;
+        }
+        const createdAt = new Date(otp.created_at);
+        const now = new Date();
+        const secondsSince = (now.getTime() - createdAt.getTime()) / 1000;
+        if (secondsSince < throttleSeconds) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Please wait ${Math.ceil(throttleSeconds - secondsSince)} seconds before requesting a new OTP.`);
+        }
+    }
+    async invalidateActiveOtps(customerId, purpose, sharedContext) {
+        await this.updateCustomerOtps({
+            selector: {
+                customer_id: customerId,
+                type: purpose,
+                consumed_at: null,
+            },
+            data: { consumed_at: new Date() },
+        }, sharedContext);
+    }
+    generateOtpCode() {
+        const { otpLength, otpCharset } = this.options_;
+        const charset = otpCharset === "alphanumeric" ? OTP_CHARSET_ALPHANUMERIC : OTP_CHARSET_NUMERIC;
+        let code = "";
+        for (let i = 0; i < otpLength; i++) {
+            const index = (0, crypto_1.randomInt)(0, charset.length);
+            code += charset[index];
+        }
+        return code;
+    }
+    calculateExpiry() {
+        const expiresAt = new Date();
+        expiresAt.setMinutes(expiresAt.getMinutes() + this.options_.otpExpiryMinutes);
+        return expiresAt;
+    }
+    hashOtp(code) {
+        return (0, crypto_1.createHash)("sha256").update(code).digest("hex");
+    }
+    async dispatchNotification({ customer, purpose, deliveryTarget, code, channelOptions, expiresAt, sharedContext, }) {
+        const notificationService = this.notificationModuleService_;
+        if (!notificationService) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Notification module is not configured. Please register at least one provider.");
+        }
+        const payload = {
+            to: deliveryTarget,
+            channel: channelOptions.channel,
+            template: channelOptions.template,
+            trigger_type: `customer-registration.${purpose}-otp`,
+            resource_type: "customer",
+            resource_id: customer.id,
+            receiver_id: customer.id,
+            data: {
+                code,
+                expires_at: expiresAt.toISOString(),
+                purpose,
+                customer_id: customer.id,
+            },
+            content: this.buildNotificationContent(purpose, code, channelOptions),
+        };
+        await notificationService.createNotifications(payload, sharedContext);
+    }
+    buildNotificationContent(purpose, code, channelOptions) {
+        if ("subject" in channelOptions) {
+            return {
+                subject: channelOptions.subject,
+                text: `Your ${purpose} verification code is ${code}`,
+                html: `<p>Your ${purpose} verification code is <strong>${code}</strong>.</p>`,
+            };
+        }
+        return {
+            text: `Your ${purpose} verification code is ${code}`,
+        };
+    }
+}
+exports.default = CustomerRegistrationModuleService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/customer-registration/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/modules/customer-registration/types.js

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

package/README.md

@@ -1,14 +1,15 @@
 # Medusa Plugin: Customer Registration Guard
 
-A lean Medusa v2 plugin that overrides the store customer registration endpoint and guarantees both `email_verified` and `phone_verified` start as `false`.
+A lean Medusa v2 plugin that hardens customer onboarding, guarantees both `email_verified` and `phone_verified` start as `false`, and now ships a full OTP verification flow for email + phone.
 
 ## Features
 
 - Overrides `POST /store/customers` with a drop-in route handler.
 - Forces `email_verified = false` and `phone_verified = false` for every new customer, regardless of the request payload.
-- Ships a lightweight Medusa module (`customer-registration`) so the bundled Mikro-ORM migration automatically runs during `npx medusa db:migrate`.
-- Adds both verification columns if they’re missing, ensuring downstream logic can rely on them.
-- No custom modules, admin extensions, subscribers, or providers — just the pieces required for registration hardening.
+- Automatically generates & sends an email OTP right after registration (configurable) using the Notification module + whatever providers your project already registered.
+- Adds dedicated email + phone OTP endpoints for resending and verifying codes while marking the corresponding `*_verified` flags to `true`.
+- Ships a lightweight Medusa module (`customer-registration`) that exposes OTP helpers and bundles Mikro-ORM migrations (email/phone columns + OTP table) that run during `npx medusa db:migrate`.
+- OTP length, charset, expiry, throttling, and provider metadata (channel, template, etc.) are all configurable via plugin options.
 
 ## Installation
 
@@ -55,19 +56,63 @@ yarn dev
 
 ### Registration override
 
-When a shopper registers via `POST /store/customers`, the plugin intercepts the request, normalizes the payload, and always persists `email_verified = false` and `phone_verified = false`. The rest of Medusa’s default behavior is preserved by deferring to the Customer Module service.
+When a shopper registers via `POST /store/customers`, the plugin intercepts the request, normalizes the payload, and always persists `email_verified = false` and `phone_verified = false`. The rest of Medusa’s default behavior is preserved by deferring to the Customer Module service. If `email.autoSendOnRegistration` is enabled (default), the plugin immediately issues an email OTP through the Notification module using the user's configured providers.
+
+### OTP endpoints
+
+The plugin adds a tiny surface area of Store API routes so storefronts can request and verify codes without touching the Admin API:
+
+| Endpoint | Body | Description |
+| --- | --- | --- |
+| `POST /store/customers/email/otp/verify` | `{ email?: string, customer_id?: string, code: string }` | Validates an email OTP and sets `email_verified = true`. |
+| `POST /store/customers/phone/otp/send` | `{ email?: string, customer_id?: string }` | Generates an OTP and sends it to the customer's phone number (stored on the customer record). |
+| `POST /store/customers/phone/otp/verify` | `{ email?: string, customer_id?: string, code: string }` | Validates a phone OTP and sets `phone_verified = true`. |
+
+All notification dispatches go through Medusa's Notification module. Whatever providers / templates you configure globally will be reused by the plugin.
+
+### Configuration
+
+You can override OTP behavior by passing options when registering the plugin:
+
+```ts
+plugins: [
+  {
+    resolve: "customer-registration",
+    options: {
+      otpLength: 6,
+      otpCharset: "numeric", // or "alphanumeric"
+      otpExpiryMinutes: 15,
+      maxAttempts: 5,
+      email: {
+        channel: "email",
+        template: "otp-template", // optional provider template handle
+        subject: "Verify your Medusa account",
+        resendThrottleSeconds: 90,
+        autoSendOnRegistration: true,
+      },
+      phone: {
+        channel: "sms",
+        template: null,
+        resendThrottleSeconds: 60,
+      },
+    },
+  },
+]
+```
+
+### Database migrations
 
-### Database migration
+- `Migration20250118000000AddEmailVerifiedColumn`: ensures the customer table includes `email_verified` and `phone_verified` booleans.
+- `Migration20250118001000CreateCustomerOtpTable`: creates the `customer_registration_otp` table for storing hashed OTPs, expiry metadata, and delivery context.
 
-- A module-scoped migration (`Migration20250118000000AddEmailVerifiedColumn`) lives under `src/modules/customer-registration/migrations`. Medusa automatically discovers it when the plugin is registered.
-- After installing or updating the plugin, run `npx medusa db:migrate` in your Medusa project so the columns exist before handling registrations.
+After installing or updating the plugin, run `npx medusa db:migrate` in your Medusa project so both migrations are applied before handling registrations.
 
 ## Requirements
 
 - Medusa v2.11.2 or higher
-- Customer table must have `email_verified` and `phone_verified` boolean columns (default: `false`) — the provided migration handles this.
-- Run `npx medusa db:migrate` after installation so the module migration is applied.
-- No additional providers, subscribers, or admin extensions are required.
+- Customer table must have `email_verified` and `phone_verified` boolean columns — handled by the bundled migration.
+- At least one Notification provider (email + optional SMS) configured in your Medusa project so OTPs can be delivered automatically.
+- Run `npx medusa db:migrate` after installation so the module migrations are applied.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "customer-registration",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "Medusa plugin that overrides store customer registration and enforces email/phone verification flags.",
   "author": "Medusa (https://medusajs.com)",
   "license": "MIT",
@@ -23,14 +23,16 @@
   "scripts": {
     "build": "medusa plugin:build",
     "dev": "medusa plugin:develop",
-    "prepublishOnly": "medusa plugin:build"
+    "prepublishOnly": "medusa plugin:build",
+    "test": "vitest run"
   },
   "devDependencies": {
     "@medusajs/cli": "2.11.2",
     "@medusajs/framework": "2.11.2",
     "@medusajs/medusa": "2.11.2",
     "ts-node": "^10.9.2",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.2",
+    "vitest": "^1.5.2"
   },
   "peerDependencies": {
     "@medusajs/cli": "2.11.2",