customer-registration 0.0.23 → 0.0.47

package/.medusa/server/src/services/notification-service.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendOTP = sendOTP;
+/**
+ * Send OTP via Medusa Notification module
+ */
+async function sendOTP(notificationService, params) {
+    const { otp, channelType, address, otpType, customerName, config } = params;
+    let channel;
+    let template;
+    let subject;
+    let resendThrottleSeconds;
+    switch (otpType) {
+        case "email_verification":
+            channel = config.email.channel;
+            template = config.email.template;
+            subject = config.email.subject;
+            break;
+        case "phone_verification":
+            channel = config.phone.channel;
+            template = config.phone.template;
+            break;
+        case "forget_password":
+            channel = config.forgetPassword.channel;
+            template = config.forgetPassword.template;
+            subject = config.forgetPassword.subject;
+            break;
+        default:
+            channel = "email";
+    }
+    const expiryMinutes = config.otpExpiryMinutes;
+    // Prepare notification data
+    const notificationData = {
+        channel,
+        to: address,
+        data: {
+            otp,
+            expiry: expiryMinutes,
+            expiry_minutes: expiryMinutes,
+            customer_name: customerName || "Customer",
+        },
+    };
+    if (template) {
+        notificationData.template = template;
+    }
+    if (subject && channelType === "email") {
+        notificationData.subject = subject;
+    }
+    try {
+        // Try to send via notification service
+        // Medusa v2 notification service typically uses 'send' method
+        const service = notificationService;
+        if (typeof service.send === "function") {
+            await service.send(notificationData);
+        }
+        else if (typeof service.create === "function") {
+            await service.create(notificationData);
+        }
+        else if (typeof service.createNotification === "function") {
+            await service.createNotification(notificationData);
+        }
+        else {
+            // If no method found, log and continue (fallback will handle it)
+            throw new Error("Notification service method not available. Available methods: " + Object.getOwnPropertyNames(service).join(", "));
+        }
+    }
+    catch (error) {
+        // Fallback to console log if notification module not configured
+        // This is expected in development/testing environments
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.log(`[customer-registration] OTP dispatch fallback (notification service unavailable):`);
+        console.log(`  Channel: ${channelType}`);
+        console.log(`  To: ${address}`);
+        console.log(`  OTP: ${otp}`);
+        console.log(`  Expires in: ${expiryMinutes} minutes`);
+        console.log(`  Error: ${errorMessage}`);
+        // In production, you might want to throw here or use a logging service
+        // For now, we silently continue to allow development without notification setup
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/subscribers/customer-created.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = customerCreatedHandler;
+const utils_1 = require("@medusajs/framework/utils");
+const notification_service_1 = require("../services/notification-service");
+const index_1 = require("../modules/customer-registration/index");
+async function customerCreatedHandler({ event: { data }, container, }) {
+    const config = container.resolve("pluginOptions");
+    // Check if auto-send is enabled
+    if (!config.email.autoSendOnRegistration) {
+        return;
+    }
+    const customerService = container.resolve(utils_1.Modules.CUSTOMER);
+    const notificationService = container.resolve(utils_1.Modules.NOTIFICATION);
+    const otpService = container.resolve(index_1.CUSTOMER_REGISTRATION_MODULE);
+    // Get customer details
+    const customer = await customerService.retrieveCustomer(data.id);
+    if (!customer.email) {
+        return;
+    }
+    try {
+        // Create and send email OTP
+        const { otp, token } = await otpService.createOTP(customer.id, "email", customer.email, "email_verification", config);
+        // Send notification
+        await (0, notification_service_1.sendOTP)(notificationService, {
+            otp,
+            channelType: "email",
+            address: customer.email,
+            otpType: "email_verification",
+            customerName: `${customer.first_name || ""} ${customer.last_name || ""}`.trim() || undefined,
+            config,
+        });
+    }
+    catch (error) {
+        console.error("[customer-registration] Error sending email OTP on registration:", error);
+    }
+}
+exports.config = {
+    event: "customer.created",
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tZXItY3JlYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zdWJzY3JpYmVycy9jdXN0b21lci1jcmVhdGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVFBLHlDQW9EQztBQTNERCxxREFBbUQ7QUFHbkQsMkVBQTBEO0FBRTFELGtFQUFxRjtBQUV0RSxLQUFLLFVBQVUsc0JBQXNCLENBQUMsRUFDbkQsS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFLEVBQ2YsU0FBUyxHQUNzRDtJQUMvRCxNQUFNLE1BQU0sR0FBRyxTQUFTLENBQUMsT0FBTyxDQUM5QixlQUFlLENBQ1csQ0FBQTtJQUU1QixnQ0FBZ0M7SUFDaEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsc0JBQXNCLEVBQUUsQ0FBQztRQUN6QyxPQUFNO0lBQ1IsQ0FBQztJQUVELE1BQU0sZUFBZSxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQ3ZDLGVBQU8sQ0FBQyxRQUFRLENBQ1MsQ0FBQTtJQUMzQixNQUFNLG1CQUFtQixHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQzNDLGVBQU8sQ0FBQyxZQUFZLENBQ1MsQ0FBQTtJQUMvQixNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUNsQyxvQ0FBNEIsQ0FDZixDQUFBO0lBRWYsdUJBQXVCO0lBQ3ZCLE1BQU0sUUFBUSxHQUFHLE1BQU0sZUFBZSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUVoRSxJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3BCLE9BQU07SUFDUixDQUFDO0lBRUQsSUFBSSxDQUFDO1FBQ0gsNEJBQTRCO1FBQzVCLE1BQU0sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxVQUFVLENBQUMsU0FBUyxDQUMvQyxRQUFRLENBQUMsRUFBRSxFQUNYLE9BQU8sRUFDUCxRQUFRLENBQUMsS0FBSyxFQUNkLG9CQUFvQixFQUNwQixNQUFNLENBQ1AsQ0FBQTtRQUVELG9CQUFvQjtRQUNwQixNQUFNLElBQUEsOEJBQU8sRUFBQyxtQkFBbUIsRUFBRTtZQUNqQyxHQUFHO1lBQ0gsV0FBVyxFQUFFLE9BQU87WUFDcEIsT0FBTyxFQUFFLFFBQVEsQ0FBQyxLQUFLO1lBQ3ZCLE9BQU8sRUFBRSxvQkFBb0I7WUFDN0IsWUFBWSxFQUFFLEdBQUcsUUFBUSxDQUFDLFVBQVUsSUFBSSxFQUFFLElBQUksUUFBUSxDQUFDLFNBQVMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLEVBQUUsSUFBSSxTQUFTO1lBQzVGLE1BQU07U0FDUCxDQUFDLENBQUE7SUFDSixDQUFDO0lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztRQUNmLE9BQU8sQ0FBQyxLQUFLLENBQUMsa0VBQWtFLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDMUYsQ0FBQztBQUNILENBQUM7QUFFWSxRQUFBLE1BQU0sR0FBcUI7SUFDdEMsS0FBSyxFQUFFLGtCQUFrQjtDQUMxQixDQUFBIn0=

package/.medusa/server/src/types/plugin-options.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePluginOptions = normalizePluginOptions;
+function normalizePluginOptions(options) {
+    return {
+        otpLength: options?.otpLength ?? 6,
+        otpCharset: options?.otpCharset ?? "numeric",
+        otpExpiryMinutes: options?.otpExpiryMinutes ?? 15,
+        maxAttempts: options?.maxAttempts ?? 5,
+        email: {
+            channel: options?.email?.channel ?? "email",
+            template: options?.email?.template ?? null,
+            subject: options?.email?.subject ?? "Verify your Medusa account",
+            resendThrottleSeconds: options?.email?.resendThrottleSeconds ?? 90,
+            autoSendOnRegistration: options?.email?.autoSendOnRegistration ?? true,
+        },
+        phone: {
+            channel: options?.phone?.channel ?? "sms",
+            template: options?.phone?.template ?? null,
+            resendThrottleSeconds: options?.phone?.resendThrottleSeconds ?? 60,
+        },
+        forgetPassword: {
+            channel: options?.forgetPassword?.channel ?? "email",
+            template: options?.forgetPassword?.template ?? null,
+            subject: options?.forgetPassword?.subject ?? "Reset your password",
+            resendThrottleSeconds: options?.forgetPassword?.resendThrottleSeconds ?? 120,
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHlwZXMvcGx1Z2luLW9wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFnQ0Esd0RBeUJDO0FBekJELFNBQWdCLHNCQUFzQixDQUFDLE9BQXVCO0lBQzVELE9BQU87UUFDTCxTQUFTLEVBQUUsT0FBTyxFQUFFLFNBQVMsSUFBSSxDQUFDO1FBQ2xDLFVBQVUsRUFBRSxPQUFPLEVBQUUsVUFBVSxJQUFJLFNBQVM7UUFDNUMsZ0JBQWdCLEVBQUUsT0FBTyxFQUFFLGdCQUFnQixJQUFJLEVBQUU7UUFDakQsV0FBVyxFQUFFLE9BQU8sRUFBRSxXQUFXLElBQUksQ0FBQztRQUN0QyxLQUFLLEVBQUU7WUFDTCxPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLElBQUksT0FBTztZQUMzQyxRQUFRLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxRQUFRLElBQUksSUFBSTtZQUMxQyxPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLElBQUksNEJBQTRCO1lBQ2hFLHFCQUFxQixFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUscUJBQXFCLElBQUksRUFBRTtZQUNsRSxzQkFBc0IsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLHNCQUFzQixJQUFJLElBQUk7U0FDdkU7UUFDRCxLQUFLLEVBQUU7WUFDTCxPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLElBQUksS0FBSztZQUN6QyxRQUFRLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxRQUFRLElBQUksSUFBSTtZQUMxQyxxQkFBcUIsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLHFCQUFxQixJQUFJLEVBQUU7U0FDbkU7UUFDRCxjQUFjLEVBQUU7WUFDZCxPQUFPLEVBQUUsT0FBTyxFQUFFLGNBQWMsRUFBRSxPQUFPLElBQUksT0FBTztZQUNwRCxRQUFRLEVBQUUsT0FBTyxFQUFFLGNBQWMsRUFBRSxRQUFRLElBQUksSUFBSTtZQUNuRCxPQUFPLEVBQUUsT0FBTyxFQUFFLGNBQWMsRUFBRSxPQUFPLElBQUkscUJBQXFCO1lBQ2xFLHFCQUFxQixFQUFFLE9BQU8sRUFBRSxjQUFjLEVBQUUscUJBQXFCLElBQUksR0FBRztTQUM3RTtLQUNGLENBQUE7QUFDSCxDQUFDIn0=

package/.medusa/server/src/utils/crypto.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashOTP = hashOTP;
+exports.compareOTP = compareOTP;
+const bcrypt = __importStar(require("bcryptjs"));
+/**
+ * Hash OTP using bcrypt
+ */
+async function hashOTP(otp) {
+    const saltRounds = 10;
+    return await bcrypt.hash(otp, saltRounds);
+}
+/**
+ * Compare OTP with hash
+ */
+async function compareOTP(otp, hash) {
+    return await bcrypt.compare(otp, hash);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3J5cHRvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL2NyeXB0by50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUtBLDBCQUdDO0FBS0QsZ0NBRUM7QUFmRCxpREFBa0M7QUFFbEM7O0dBRUc7QUFDSSxLQUFLLFVBQVUsT0FBTyxDQUFDLEdBQVc7SUFDdkMsTUFBTSxVQUFVLEdBQUcsRUFBRSxDQUFBO0lBQ3JCLE9BQU8sTUFBTSxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxVQUFVLENBQUMsQ0FBQTtBQUMzQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSSxLQUFLLFVBQVUsVUFBVSxDQUFDLEdBQVcsRUFBRSxJQUFZO0lBQ3hELE9BQU8sTUFBTSxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxJQUFJLENBQUMsQ0FBQTtBQUN4QyxDQUFDIn0=

package/.medusa/server/src/utils/customer-update.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCustomerVerificationFields = updateCustomerVerificationFields;
+exports.findCustomerByPhone = findCustomerByPhone;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Update customer verification fields using EntityManager for direct database access
+ * This is necessary because custom fields may not be supported by the customer service API
+ */
+async function updateCustomerVerificationFields(manager, customerId, fields) {
+    try {
+        const updateData = {};
+        if (fields.email_verified !== undefined) {
+            updateData.email_verified = fields.email_verified;
+        }
+        if (fields.phone_verified !== undefined) {
+            updateData.phone_verified = fields.phone_verified;
+        }
+        if (Object.keys(updateData).length === 0) {
+            return;
+        }
+        // Use native update for custom fields
+        await manager.nativeUpdate("customer", { id: customerId }, updateData);
+    }
+    catch (error) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Failed to update customer verification fields: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}
+/**
+ * Find customer by phone number using EntityManager
+ * Fallback when customer service doesn't support phone filter
+ */
+async function findCustomerByPhone(manager, phone) {
+    try {
+        // Use native query for direct database access
+        const connection = manager.getConnection();
+        const result = await connection.execute('SELECT id FROM customer WHERE phone = $1 LIMIT 1', [phone]);
+        if (Array.isArray(result) && result.length > 0 && result[0]) {
+            return { id: result[0].id };
+        }
+        return null;
+    }
+    catch (error) {
+        console.error("[customer-registration] Error finding customer by phone:", error);
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tZXItdXBkYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL2N1c3RvbWVyLXVwZGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVFBLDRFQWdDQztBQU1ELGtEQXFCQztBQWpFRCxxREFBdUQ7QUFFdkQ7OztHQUdHO0FBQ0ksS0FBSyxVQUFVLGdDQUFnQyxDQUNwRCxPQUFzQixFQUN0QixVQUFrQixFQUNsQixNQUE4RDtJQUU5RCxJQUFJLENBQUM7UUFDSCxNQUFNLFVBQVUsR0FBNEIsRUFBRSxDQUFBO1FBRTlDLElBQUksTUFBTSxDQUFDLGNBQWMsS0FBSyxTQUFTLEVBQUUsQ0FBQztZQUN4QyxVQUFVLENBQUMsY0FBYyxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUE7UUFDbkQsQ0FBQztRQUVELElBQUksTUFBTSxDQUFDLGNBQWMsS0FBSyxTQUFTLEVBQUUsQ0FBQztZQUN4QyxVQUFVLENBQUMsY0FBYyxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUE7UUFDbkQsQ0FBQztRQUVELElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDekMsT0FBTTtRQUNSLENBQUM7UUFFRCxzQ0FBc0M7UUFDdEMsTUFBTSxPQUFPLENBQUMsWUFBWSxDQUN4QixVQUFVLEVBQ1YsRUFBRSxFQUFFLEVBQUUsVUFBVSxFQUFFLEVBQ2xCLFVBQVUsQ0FDWCxDQUFBO0lBQ0gsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZixNQUFNLElBQUksbUJBQVcsQ0FDbkIsbUJBQVcsQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLEVBQ2xDLGtEQUFrRCxLQUFLLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxlQUFlLEVBQUUsQ0FDN0csQ0FBQTtJQUNILENBQUM7QUFDSCxDQUFDO0FBRUQ7OztHQUdHO0FBQ0ksS0FBSyxVQUFVLG1CQUFtQixDQUN2QyxPQUFzQixFQUN0QixLQUFhO0lBRWIsSUFBSSxDQUFDO1FBQ0gsOENBQThDO1FBQzlDLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxhQUFhLEVBQUUsQ0FBQTtRQUMxQyxNQUFNLE1BQU0sR0FBRyxNQUFNLFVBQVUsQ0FBQyxPQUFPLENBQ3JDLGtEQUFrRCxFQUNsRCxDQUFDLEtBQUssQ0FBQyxDQUNSLENBQUE7UUFFRCxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLElBQUksTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDNUQsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBWSxFQUFFLENBQUE7UUFDdkMsQ0FBQztRQUVELE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZixPQUFPLENBQUMsS0FBSyxDQUFDLDBEQUEwRCxFQUFFLEtBQUssQ0FBQyxDQUFBO1FBQ2hGLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztBQUNILENBQUMifQ==

package/.medusa/server/src/utils/otp-generator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNumericOTP = generateNumericOTP;
+exports.generateAlphanumericOTP = generateAlphanumericOTP;
+/**
+ * Generate numeric OTP
+ */
+function generateNumericOTP(length) {
+    const min = Math.pow(10, length - 1);
+    const max = Math.pow(10, length) - 1;
+    const otp = Math.floor(Math.random() * (max - min + 1)) + min;
+    return otp.toString();
+}
+/**
+ * Generate alphanumeric OTP (digits + consonants, excluding vowels and ambiguous characters)
+ */
+function generateAlphanumericOTP(length) {
+    // Use digits and consonants only (excluding vowels and ambiguous characters like 0, O, I, 1, l)
+    const charset = "23456789BCDFGHJKLMNPQRSTVWXYZ";
+    let otp = "";
+    for (let i = 0; i < length; i++) {
+        const randomIndex = Math.floor(Math.random() * charset.length);
+        otp += charset[randomIndex];
+    }
+    return otp;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RwLWdlbmVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9vdHAtZ2VuZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsZ0RBS0M7QUFLRCwwREFXQztBQXhCRDs7R0FFRztBQUNILFNBQWdCLGtCQUFrQixDQUFDLE1BQWM7SUFDL0MsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFBO0lBQ3BDLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQTtJQUNwQyxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDLEdBQUcsR0FBRyxHQUFHLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUE7SUFDN0QsT0FBTyxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUE7QUFDdkIsQ0FBQztBQUVEOztHQUVHO0FBQ0gsU0FBZ0IsdUJBQXVCLENBQUMsTUFBYztJQUNwRCxnR0FBZ0c7SUFDaEcsTUFBTSxPQUFPLEdBQUcsK0JBQStCLENBQUE7SUFDL0MsSUFBSSxHQUFHLEdBQUcsRUFBRSxDQUFBO0lBRVosS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ2hDLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQTtRQUM5RCxHQUFHLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQUFBO0lBQzdCLENBQUM7SUFFRCxPQUFPLEdBQUcsQ0FBQTtBQUNaLENBQUMifQ==

package/.medusa/server/src/utils/token-generator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateToken = generateToken;
+const crypto_1 = require("crypto");
+/**
+ * Generate unique token for OTP record
+ */
+function generateToken() {
+    return (0, crypto_1.randomBytes)(32).toString("hex");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tZ2VuZXJhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL3Rva2VuLWdlbmVyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUtBLHNDQUVDO0FBUEQsbUNBQW9DO0FBRXBDOztHQUVHO0FBQ0gsU0FBZ0IsYUFBYTtJQUMzQixPQUFPLElBQUEsb0JBQVcsRUFBQyxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDeEMsQ0FBQyJ9

package/README.md

@@ -4,7 +4,7 @@ A lean Medusa v2 plugin that hardens customer onboarding, guarantees both `email
 
 ## Features
 
-- Overrides `POST /store/customers` with a drop-in route handler.
+- Listens to Medusa's native `customer.created` event, so OTP automation works without overriding `POST /store/customers`.
 - Forces `email_verified = false` and `phone_verified = false` for every new customer, regardless of the request payload.
 - 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`.
@@ -54,52 +54,176 @@ yarn dev
 
 ## Usage
 
-### Registration override
+### Registration lifecycle hook
 
-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.
+The plugin no longer overrides `POST /store/customers`. Instead, it listens to the `customer.created` event and automatically issues an email OTP (when `email.autoSendOnRegistration` is enabled). Because the default Medusa route still handles persistence and response formatting, there are no behavioral differences for registration requests aside from the verification guard.
 
 ### 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:
+Expose these Store API routes to your frontend so shoppers can complete verification without touching the Admin API:
 
-| Endpoint | Body | Description |
+| Endpoint | Request 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`. |
+| `POST /store/customers/email/otp/verify` | `{ email?: string; customer_id?: string; code: string }` | Confirms the latest email OTP and flips `email_verified` to `true`. |
+| `POST /store/customers/phone/otp/send` | `{ email?: string; customer_id?: string }` | Generates a new OTP, throttled per config, and sends it via your configured SMS channel. |
+| `POST /store/customers/phone/otp/verify` | `{ email?: string; customer_id?: string; code: string }` | Confirms the latest phone OTP and flips `phone_verified` to `true`. |
 
-All notification dispatches go through Medusa's Notification module. Whatever providers / templates you configure globally will be reused by the plugin.
+All notification dispatches go through Medusa's Notification module, so whichever providers/templates your project already registers will be used automatically.
 
-### Configuration
+#### Example: send phone OTP
 
-You can override OTP behavior by passing options when registering the plugin:
+Request:
+
+```http
+POST /store/customers/phone/otp/send
+Content-Type: application/json
+
+{
+  "email": "sarah@example.com"
+}
+```
+
+Response:
+
+```json
+{
+  "sent": true
+}
+```
+
+#### Example: verify email OTP
+
+Request:
+
+```http
+POST /store/customers/email/otp/verify
+Content-Type: application/json
+
+{
+  "customer_id": "cus_01J7J6PSJ8K7XR31R3Q0H0RZ5Q",
+  "code": "529104"
+}
+```
+
+Response:
+
+```json
+{
+  "customer": {
+    "id": "cus_01J7J6PSJ8K7XR31R3Q0H0RZ5Q",
+    "email": "sarah@example.com",
+    "phone": "+12025550123",
+    "email_verified": true,
+    "phone_verified": false,
+    "...": "other Medusa customer fields"
+  }
+}
+```
+
+### Typical storefront flow
+
+1. **Register** – call `POST /store/customers` as usual (plugin sets both verification flags to `false`).  
+2. **Auto email OTP (optional)** – if `email.autoSendOnRegistration` is `true`, the plugin immediately emails the code.  
+3. **Resend OTP** – expose “Resend email/phone code” buttons that hit `POST /store/customers/email/otp/verify` or `POST /store/customers/phone/otp/send`.  
+4. **Verify** – when the user submits the code, call the corresponding verify endpoint; the plugin marks the customer as verified and returns the updated customer object.
+
+### End-to-end OTP integration guide
+
+Follow this sequence to enforce verification before login. Each step shows the minimal payloads and cURL commands your storefront or test suite can run.
+
+1. **Register the customer (no cookies returned)**  
+   ```bash
+   curl -X POST http://localhost:9000/store/customers \
+     -H "Content-Type: application/json" \
+     -d '{
+       "first_name": "Ava",
+       "last_name": "Lopez",
+       "email": "ava@example.com",
+       "password": "S3cret!123"
+     }'
+   ```
+   The response contains `customer.email_verified = false`. If `email.autoSendOnRegistration` is enabled, an OTP is already dispatched (and logged to the console when no notification module is configured).
+
+2. **Verify the email OTP**  
+   ```bash
+   curl -X POST http://localhost:9000/store/customers/email/otp/verify \
+     -H "Content-Type: application/json" \
+     -d '{
+       "email": "ava@example.com",
+       "code": "123456"
+     }'
+   ```
+   On success the returned customer now has `email_verified = true`. If an incorrect or expired code is provided, you receive a `400` or `403` style Medusa error describing the reason and you can prompt the shopper to retry.
+
+3. **Login via Medusa auth endpoint (email verification enforced)**  
+   The plugin overrides `POST /auth/customer/emailpass` so tokens issue only when `email_verified` is true.
+   ```bash
+   curl -X POST http://localhost:9000/auth/customer/emailpass \
+     -H "Content-Type: application/json" \
+     -d '{
+       "email": "ava@example.com",
+       "password": "S3cret!123"
+     }'
+   ```
+   - If the email is verified, the response matches Medusa core (`{ "token": "..." }`).
+   - If not verified, the route returns `401` with `message: "Please verify your email before logging in."`
+
+4. **(Optional) Phone verification gating**  
+   - During registration and OTP verification responses you always receive the latest `phone_verified` flag alongside `email_verified`.
+   - In an account or profile screen, read these flags from `GET /store/customers/me`. When `phone_verified` is `false`, show a CTA that calls `POST /store/customers/phone/otp/send` and `POST /store/customers/phone/otp/verify` just like the email flow.  
+   - Once both flags are true, hide the prompts or replace them with a “Verified” badge.
+
+> Hint: For QA environments without providers, OTP codes are logged with the `[customer-registration] OTP dispatch fallback` prefix so testers can copy/paste them while still exercising the full API surface.
+
+### Configuration reference
+
+Declare the plugin inside `medusa-config.ts` with the options that match your UX and provider setup:
 
 ```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,
+import { defineConfig } from "@medusajs/framework/utils"
+
+export default defineConfig({
+  // ...
+  plugins: [
+    {
+      resolve: "customer-registration",
+      options: {
+        otpLength: 6,
+        otpCharset: "numeric",            // "numeric" or "alphanumeric"
+        otpExpiryMinutes: 15,
+        maxAttempts: 5,
+        email: {
+          channel: "email",               // Medusa notification channel key
+          template: "otp-email-verify",   // optional provider template
+          subject: "Verify your Medusa account",
+          resendThrottleSeconds: 90,
+          autoSendOnRegistration: true,
+        },
+        phone: {
+          channel: "sms",
+          template: "otp-phone-verify",
+          resendThrottleSeconds: 60,
+        },
       },
     },
-  },
-]
+  ],
+})
 ```
 
+| Option | Type | Description |
+| --- | --- | --- |
+| `otpLength` | `number` | Total characters generated per OTP. |
+| `otpCharset` | `"numeric" \| "alphanumeric"` | Controls whether codes contain digits only or digits + consonants. |
+| `otpExpiryMinutes` | `number` | Minutes before each OTP expires. |
+| `maxAttempts` | `number` | Number of failed attempts before forcing a resend. |
+| `email.channel` / `phone.channel` | `string` | Notification channel key registered in Medusa (e.g., `email`, `sms`). |
+| `email.template` / `phone.template` | `string \| null` | Optional provider template handle (SendGrid ID, Twilio template, etc.). |
+| `email.subject` | `string` | Fallback subject when sending raw email content. |
+| `email.autoSendOnRegistration` | `boolean` | Auto-dispatch an email OTP immediately after registration. |
+| `email.resendThrottleSeconds` / `phone.resendThrottleSeconds` | `number` | Minimum seconds before another OTP can be requested for the same purpose. |
+
+> Tip: leave `template` as `null` to fall back to the built-in plain-text message content; otherwise provide the template ID your provider expects.
+
 ### Database migrations
 
 - `Migration20250118000000AddEmailVerifiedColumn`: ensures the customer table includes `email_verified` and `phone_verified` booleans.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "customer-registration",
-  "version": "0.0.23",
+  "version": "0.0.47",
   "description": "Medusa plugin that overrides store customer registration and enforces email/phone verification flags.",
   "author": "Medusa (https://medusajs.com)",
   "license": "MIT",
@@ -30,6 +30,8 @@
     "@medusajs/cli": "2.11.2",
     "@medusajs/framework": "2.11.2",
     "@medusajs/medusa": "2.11.2",
+    "@types/bcryptjs": "^2.4.6",
+    "bcryptjs": "^2.4.3",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.2",
     "vitest": "^1.5.2"

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

@@ -1,48 +0,0 @@
-"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=