@lodashventure/medusa-login-provider 0.0.7 → 0.0.8

package/.medusa/server/medusa-config-auth.example.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Example Medusa configuration with LINE auth provider
+ *
+ * Add this auth module configuration to your medusa-config.ts
+ */
+exports.default = (0, utils_1.defineConfig)({
+    projectConfig: {
+        // ... your existing project config
+        databaseUrl: process.env.MEDUSA_DATABASE_URL,
+        http: {
+            storeCors: process.env.MEDUSA_STORE_CORS,
+            adminCors: process.env.MEDUSA_ADMIN_CORS,
+            authCors: process.env.MEDUSA_AUTH_CORS,
+            jwtSecret: process.env.MEDUSA_JWT_SECRET || "supersecret",
+            cookieSecret: process.env.MEDUSA_COOKIE_SECRET || "supersecret",
+        },
+    },
+    plugins: [
+    // Remove the LINE provider from plugins section if it's there
+    // ... other plugins
+    ],
+    modules: [
+        // ... other modules
+        {
+            resolve: "@medusajs/medusa/auth",
+            options: {
+                providers: [
+                    // Keep existing providers like emailpass
+                    {
+                        resolve: "@medusajs/medusa/auth-emailpass",
+                        id: "emailpass",
+                        options: {
+                        // emailpass options
+                        },
+                    },
+                    // Add LINE provider here
+                    {
+                        resolve: "@lodashventure/medusa-login-provider/providers/line",
+                        id: "line",
+                        options: {
+                            lineChannelId: process.env.LINE_CHANNEL_ID,
+                            lineChannelSecret: process.env.LINE_CHANNEL_SECRET,
+                            // Optional: specify callback URL if different from default
+                            callbackUrl: process.env.LINE_CALLBACK_URL,
+                            // Optional: auto-create customers
+                            autoCreateCustomer: true,
+                            syncProfileData: true,
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkdXNhLWNvbmZpZy1hdXRoLmV4YW1wbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9tZWR1c2EtY29uZmlnLWF1dGguZXhhbXBsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHFEQUFrRTtBQUVsRTs7OztHQUlHO0FBQ0gsa0JBQWUsSUFBQSxvQkFBWSxFQUFDO0lBQzFCLGFBQWEsRUFBRTtRQUNiLG1DQUFtQztRQUNuQyxXQUFXLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxtQkFBbUI7UUFDNUMsSUFBSSxFQUFFO1lBQ0osU0FBUyxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUJBQWtCO1lBQ3pDLFNBQVMsRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLGlCQUFrQjtZQUN6QyxRQUFRLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxnQkFBaUI7WUFDdkMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUJBQWlCLElBQUksYUFBYTtZQUN6RCxZQUFZLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxvQkFBb0IsSUFBSSxhQUFhO1NBQ2hFO0tBQ0Y7SUFDRCxPQUFPLEVBQUU7SUFDUCw4REFBOEQ7SUFDOUQsb0JBQW9CO0tBQ3JCO0lBQ0QsT0FBTyxFQUFFO1FBQ1Asb0JBQW9CO1FBQ3BCO1lBQ0UsT0FBTyxFQUFFLHVCQUF1QjtZQUNoQyxPQUFPLEVBQUU7Z0JBQ1AsU0FBUyxFQUFFO29CQUNULHlDQUF5QztvQkFDekM7d0JBQ0UsT0FBTyxFQUFFLGlDQUFpQzt3QkFDMUMsRUFBRSxFQUFFLFdBQVc7d0JBQ2YsT0FBTyxFQUFFO3dCQUNQLG9CQUFvQjt5QkFDckI7cUJBQ0Y7b0JBQ0QseUJBQXlCO29CQUN6Qjt3QkFDRSxPQUFPLEVBQUUscURBQXFEO3dCQUM5RCxFQUFFLEVBQUUsTUFBTTt3QkFDVixPQUFPLEVBQUU7NEJBQ1AsYUFBYSxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZTs0QkFDMUMsaUJBQWlCLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxtQkFBbUI7NEJBQ2xELDJEQUEyRDs0QkFDM0QsV0FBVyxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUJBQWlCOzRCQUMxQyxrQ0FBa0M7NEJBQ2xDLGtCQUFrQixFQUFFLElBQUk7NEJBQ3hCLGVBQWUsRUFBRSxJQUFJO3lCQUN0QjtxQkFDRjtpQkFDRjthQUNGO1NBQ0Y7S0FDRjtDQUNGLENBQUMsQ0FBQyJ9

package/.medusa/server/src/api/store/line-pending-customers/route.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+exports.GET = GET;
+const utils_1 = require("@medusajs/framework/utils");
+const ioredis_1 = __importDefault(require("ioredis"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const line_create_customer_1 = require("../../../workflows/line-create-customer");
+/**
+ * POST /store/line-pending-customers
+ * Creates a customer from pending LINE data stored in Redis
+ * Requires JWT with auth_identity_id
+ */
+async function POST(req, res) {
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const customerService = req.scope.resolve(utils_1.Modules.CUSTOMER);
+    // Extract JWT from Authorization header
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return res.status(401).json({
+            success: false,
+            error: "Authorization header with Bearer token is required"
+        });
+    }
+    const token = authHeader.substring(7);
+    let auth_identity_id;
+    try {
+        // Decode JWT to get auth_identity_id (no verification, just decode)
+        const decoded = jsonwebtoken_1.default.decode(token);
+        if (!decoded || !decoded.auth_identity_id) {
+            return res.status(401).json({
+                success: false,
+                error: "Invalid token: auth_identity_id not found"
+            });
+        }
+        auth_identity_id = decoded.auth_identity_id;
+        logger.info(`Extracted auth_identity_id from JWT: ${auth_identity_id}`);
+    }
+    catch (error) {
+        logger.error("Error decoding JWT:", error);
+        return res.status(401).json({
+            success: false,
+            error: "Invalid token"
+        });
+    }
+    // Get Redis URL from environment
+    const redisUrl = process.env.MEDUSA_REDIS_URL || process.env.REDIS_URL;
+    if (!redisUrl) {
+        return res.status(503).json({
+            success: false,
+            error: "Redis is not configured"
+        });
+    }
+    const redis = new ioredis_1.default(redisUrl);
+    const key = `line:pending_customer:${auth_identity_id}`;
+    try {
+        // Step 1: Retrieve pending customer data from Redis using auth_identity_id
+        const pendingDataStr = await redis.get(key);
+        if (!pendingDataStr) {
+            logger.warn(`No pending customer data found for auth_identity_id: ${auth_identity_id}`);
+            return res.status(404).json({
+                success: false,
+                error: "No pending customer data found for this auth_identity_id"
+            });
+        }
+        const pendingData = JSON.parse(pendingDataStr);
+        logger.info(`Retrieved pending customer data for LINE user: ${pendingData.line_user_id}`);
+        // Step 2: Check if customer already exists with this email
+        if (pendingData.email) {
+            const existingCustomers = await customerService.listCustomers({
+                email: pendingData.email
+            });
+            if (existingCustomers?.length > 0) {
+                // Update existing customer with LINE data
+                const customer = existingCustomers[0];
+                const updated = await customerService.updateCustomers(customer.id, {
+                    metadata: {
+                        ...customer.metadata,
+                        line_user_id: pendingData.line_user_id,
+                        line_display_name: pendingData.display_name,
+                        line_picture_url: pendingData.picture_url,
+                        line_status_message: pendingData.status_message,
+                        line_linked_at: new Date().toISOString(),
+                        auth_identity_id: auth_identity_id
+                    }
+                });
+                // Step 3: Update auth identity with customer ID
+                const authService = req.scope.resolve(utils_1.Modules.AUTH);
+                await authService.updateAuthIdentities({
+                    id: auth_identity_id,
+                    app_metadata: {
+                        customer_id: customer.id
+                    }
+                });
+                // Step 4: Delete from Redis after successful creation
+                await redis.del(key);
+                logger.info(`Linked existing customer ${customer.id} with LINE user ${pendingData.line_user_id}`);
+                return res.json({
+                    success: true,
+                    customer: updated,
+                    message: "Existing customer linked with LINE account",
+                    action: "linked"
+                });
+            }
+        }
+        // Step 3: Create new customer using workflow
+        logger.info(`Creating new customer for LINE user: ${pendingData.line_user_id}`);
+        const { result } = await (0, line_create_customer_1.lineCreateCustomerWorkflow)(req.scope).run({
+            input: {
+                data: {
+                    email: pendingData.email || `line_${pendingData.line_user_id}@line.me`,
+                    line_user_id: pendingData.line_user_id,
+                    display_name: pendingData.display_name,
+                    picture_url: pendingData.picture_url,
+                    name: pendingData.name,
+                    auth_identity_id: auth_identity_id
+                }
+            }
+        });
+        // Step 4: Update auth identity with customer ID
+        const authService = req.scope.resolve(utils_1.Modules.AUTH);
+        await authService.updateAuthIdentities({
+            id: auth_identity_id,
+            app_metadata: {
+                customer_id: result.customer.id
+            }
+        });
+        // Step 5: Delete from Redis after successful creation
+        await redis.del(key);
+        logger.info(`Created customer ${result.customer.id} from pending LINE data for auth_identity ${auth_identity_id}`);
+        return res.status(201).json({
+            success: true,
+            customer: result.customer,
+            message: "Customer created successfully from LINE data",
+            action: "created"
+        });
+    }
+    catch (error) {
+        logger.error("Error creating customer from pending LINE data:", error);
+        return res.status(500).json({
+            success: false,
+            error: error.message || "Failed to create customer"
+        });
+    }
+    finally {
+        await redis.quit();
+    }
+}
+/**
+ * GET /store/line-pending-customers
+ * Checks if pending customer data exists for the auth_identity_id in JWT
+ */
+async function GET(req, res) {
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    // Extract JWT from Authorization header
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return res.status(401).json({
+            success: false,
+            error: "Authorization header with Bearer token is required"
+        });
+    }
+    const token = authHeader.substring(7);
+    let auth_identity_id;
+    try {
+        // Decode JWT to get auth_identity_id
+        const decoded = jsonwebtoken_1.default.decode(token);
+        if (!decoded || !decoded.auth_identity_id) {
+            return res.status(401).json({
+                success: false,
+                error: "Invalid token: auth_identity_id not found"
+            });
+        }
+        auth_identity_id = decoded.auth_identity_id;
+    }
+    catch (error) {
+        logger.error("Error decoding JWT:", error);
+        return res.status(401).json({
+            success: false,
+            error: "Invalid token"
+        });
+    }
+    const redisUrl = process.env.MEDUSA_REDIS_URL || process.env.REDIS_URL;
+    if (!redisUrl) {
+        return res.status(503).json({
+            success: false,
+            error: "Redis is not configured"
+        });
+    }
+    const redis = new ioredis_1.default(redisUrl);
+    const key = `line:pending_customer:${auth_identity_id}`;
+    try {
+        const pendingDataStr = await redis.get(key);
+        if (!pendingDataStr) {
+            return res.json({
+                success: true,
+                has_pending_data: false,
+                message: "No pending customer data found"
+            });
+        }
+        const pendingData = JSON.parse(pendingDataStr);
+        return res.json({
+            success: true,
+            has_pending_data: true,
+            pending_customer: pendingData
+        });
+    }
+    catch (error) {
+        logger.error("Error retrieving pending customer data:", error);
+        return res.status(500).json({
+            success: false,
+            error: "Failed to retrieve pending customer data"
+        });
+    }
+    finally {
+        await redis.quit();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route.js","sourceRoot":"","sources":["../../../../../../src/api/store/line-pending-customers/route.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineProvider = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const service_1 = __importDefault(require("./providers/line/service"));
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.AUTH, {
+    services: [service_1.default],
+});
+// Export the LINE provider for direct access
+var service_2 = require("./providers/line/service");
+Object.defineProperty(exports, "LineProvider", { enumerable: true, get: function () { return __importDefault(service_2).default; } });
+__exportStar(require("./providers/line/customer-helper"), exports);
+__exportStar(require("./providers/line/utils"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxREFBb0U7QUFDcEUsdUVBQTJEO0FBRTNELGtCQUFlLElBQUEsc0JBQWMsRUFBQyxlQUFPLENBQUMsSUFBSSxFQUFFO0lBQzFDLFFBQVEsRUFBRSxDQUFDLGlCQUFtQixDQUFDO0NBQ2hDLENBQUMsQ0FBQztBQUVILDZDQUE2QztBQUM3QyxvREFBbUU7QUFBMUQsd0hBQUEsT0FBTyxPQUFnQjtBQUNoQyxtRUFBaUQ7QUFDakQseURBQXVDIn0=

package/.medusa/server/src/providers/line/customer-helper.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrUpdateLineCustomer = createOrUpdateLineCustomer;
+exports.extractCustomerData = extractCustomerData;
+exports.shouldCreateCustomer = shouldCreateCustomer;
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Creates or updates a customer account for a LINE authenticated user
+ * Uses Medusa's createCustomerAccountWorkflow for proper integration
+ */
+async function createOrUpdateLineCustomer(options) {
+    const { authIdentityId, userMetadata, container, logger } = options;
+    const customerService = container.resolve(utils_1.Modules.CUSTOMER);
+    const authService = container.resolve(utils_1.Modules.AUTH);
+    const email = userMetadata.email || `line_${userMetadata.line_user_id}@line.me`;
+    const firstName = userMetadata.first_name || userMetadata.display_name || "LINE User";
+    const lastName = userMetadata.last_name || "";
+    try {
+        // Check if customer already exists
+        const existingCustomers = await customerService.listCustomers({ email });
+        if (existingCustomers?.length > 0) {
+            // Update existing customer
+            const customer = existingCustomers[0];
+            await customerService.updateCustomers(customer.id, {
+                first_name: firstName,
+                last_name: lastName,
+                metadata: {
+                    ...customer.metadata,
+                    line_user_id: userMetadata.line_user_id,
+                    line_display_name: userMetadata.display_name,
+                    line_picture_url: userMetadata.picture_url,
+                    line_status_message: userMetadata.status_message,
+                    line_updated_at: new Date().toISOString(),
+                },
+            });
+            // Update auth identity with customer ID
+            await authService.updateAuthIdentities({
+                id: authIdentityId,
+                app_metadata: {
+                    customer_id: customer.id,
+                },
+            });
+            if (logger) {
+                logger.info(`Updated existing customer ${customer.id} for LINE user ${userMetadata.line_user_id}`);
+            }
+            return { customer, created: false };
+        }
+        // Create new customer using workflow
+        const { result } = await (0, core_flows_1.createCustomerAccountWorkflow)(container).run({
+            input: {
+                authIdentityId,
+                customerData: {
+                    email,
+                    first_name: firstName,
+                    last_name: lastName,
+                    metadata: {
+                        line_user_id: userMetadata.line_user_id,
+                        line_display_name: userMetadata.display_name,
+                        line_picture_url: userMetadata.picture_url,
+                        line_status_message: userMetadata.status_message,
+                        line_created_at: new Date().toISOString(),
+                    },
+                },
+            },
+        });
+        if (logger) {
+            logger.info(`Created new customer ${result.id} for LINE user ${userMetadata.line_user_id}`);
+        }
+        return { customer: result, created: true };
+    }
+    catch (error) {
+        if (logger) {
+            logger.error(`Failed to create/update customer for LINE user ${userMetadata.line_user_id}:`, error);
+        }
+        // Fallback: Try direct customer creation
+        try {
+            const customer = await customerService.createCustomers({
+                email,
+                first_name: firstName,
+                last_name: lastName,
+                metadata: {
+                    line_user_id: userMetadata.line_user_id,
+                    line_display_name: userMetadata.display_name,
+                    line_picture_url: userMetadata.picture_url,
+                    line_status_message: userMetadata.status_message,
+                    line_created_at: new Date().toISOString(),
+                    auth_identity_id: authIdentityId,
+                },
+            });
+            // Update auth identity with customer ID
+            await authService.updateAuthIdentities({
+                id: authIdentityId,
+                app_metadata: {
+                    customer_id: customer.id,
+                },
+            });
+            if (logger) {
+                logger.info(`Created customer ${customer.id} via fallback method for LINE user ${userMetadata.line_user_id}`);
+            }
+            return { customer, created: true };
+        }
+        catch (fallbackError) {
+            if (logger) {
+                logger.error(`Fallback customer creation also failed:`, fallbackError);
+            }
+            throw fallbackError;
+        }
+    }
+}
+/**
+ * Extract customer data from LINE user metadata
+ */
+function extractCustomerData(userMetadata) {
+    const email = userMetadata.email || `line_${userMetadata.line_user_id}@line.me`;
+    const displayName = userMetadata.name || userMetadata.display_name || "";
+    const nameParts = displayName.trim().split(" ");
+    return {
+        email,
+        first_name: userMetadata.first_name || nameParts[0] || "LINE User",
+        last_name: userMetadata.last_name || nameParts.slice(1).join(" ") || "",
+        metadata: {
+            line_user_id: userMetadata.line_user_id,
+            line_display_name: userMetadata.display_name,
+            line_picture_url: userMetadata.picture_url || userMetadata.picture,
+            line_status_message: userMetadata.status_message,
+        },
+    };
+}
+/**
+ * Check if a customer needs to be created based on auth identity
+ */
+async function shouldCreateCustomer(authIdentity, container) {
+    // Check if customer creation flag is set
+    if (!authIdentity.user_metadata?.needs_customer_creation) {
+        return false;
+    }
+    // Check if customer already exists in app_metadata
+    if (authIdentity.app_metadata?.customer_id) {
+        const customerService = container.resolve(utils_1.Modules.CUSTOMER);
+        try {
+            await customerService.retrieveCustomer(authIdentity.app_metadata.customer_id);
+            return false; // Customer exists
+        }
+        catch {
+            // Customer doesn't exist, should create
+            return true;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/providers/line/index.js

@@ -5,7 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/framework/utils");
 const service_1 = __importDefault(require("./service"));
+const services = [service_1.default];
 exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.AUTH, {
-    services: [service_1.default],
+    services,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2xpbmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxxREFBb0U7QUFDcEUsd0RBQTRDO0FBRTVDLGtCQUFlLElBQUEsc0JBQWMsRUFBQyxlQUFPLENBQUMsSUFBSSxFQUFFO0lBQzFDLFFBQVEsRUFBRSxDQUFDLGlCQUFtQixDQUFDO0NBQ2hDLENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2xpbmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxxREFBb0U7QUFDcEUsd0RBQTRDO0FBRTVDLE1BQU0sUUFBUSxHQUFHLENBQUMsaUJBQW1CLENBQUMsQ0FBQztBQUV2QyxrQkFBZSxJQUFBLHNCQUFjLEVBQUMsZUFBTyxDQUFDLElBQUksRUFBRTtJQUMxQyxRQUFRO0NBQ1QsQ0FBQyxDQUFDIn0=

package/.medusa/server/src/providers/line/redis-helper.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineRedisHelper = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+class LineRedisHelper {
+    constructor(redisUrl, logger) {
+        this.PREFIX = "line:pending_customer:";
+        this.TTL_SECONDS = 86400; // 24 hours
+        this.redis = new ioredis_1.default(redisUrl);
+        this.logger = logger;
+    }
+    /**
+     * Store pending customer data in Redis with TTL
+     * Uses auth_identity_id as the key for easy retrieval
+     */
+    async storePendingCustomer(authIdentityId, data) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        const pendingData = {
+            ...data,
+            created_at: new Date().toISOString(),
+            expires_at: new Date(Date.now() + this.TTL_SECONDS * 1000).toISOString(),
+        };
+        try {
+            await this.redis.setex(key, this.TTL_SECONDS, JSON.stringify(pendingData));
+            this.logger.info(`Stored pending customer in Redis: ${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to store pending customer in Redis: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Retrieve pending customer data from Redis by auth_identity_id
+     */
+    async getPendingCustomer(authIdentityId) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            const data = await this.redis.get(key);
+            if (!data) {
+                return null;
+            }
+            return JSON.parse(data);
+        }
+        catch (error) {
+            this.logger.error(`Failed to get pending customer from Redis: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Delete pending customer data from Redis (after successful creation)
+     */
+    async deletePendingCustomer(authIdentityId) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            await this.redis.del(key);
+            this.logger.info(`Deleted pending customer from Redis: ${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to delete pending customer from Redis: ${error}`);
+        }
+    }
+    /**
+     * Get all pending customers (for admin monitoring)
+     */
+    async getAllPendingCustomers() {
+        try {
+            const pattern = `${this.PREFIX}*`;
+            const keys = await this.redis.keys(pattern);
+            if (keys.length === 0) {
+                return [];
+            }
+            const pipeline = this.redis.pipeline();
+            keys.forEach(key => pipeline.get(key));
+            const results = await pipeline.exec();
+            const pendingCustomers = [];
+            results?.forEach(([err, data]) => {
+                if (!err && data) {
+                    try {
+                        pendingCustomers.push(JSON.parse(data));
+                    }
+                    catch (parseError) {
+                        this.logger.error(`Failed to parse pending customer data: ${parseError}`);
+                    }
+                }
+            });
+            return pendingCustomers;
+        }
+        catch (error) {
+            this.logger.error(`Failed to get all pending customers from Redis: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Check if customer data exists in Redis
+     */
+    async hasPendingCustomer(authIdentityId) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            const exists = await this.redis.exists(key);
+            return exists === 1;
+        }
+        catch (error) {
+            this.logger.error(`Failed to check pending customer in Redis: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Update TTL for pending customer
+     */
+    async extendTTL(authIdentityId, additionalSeconds = 86400) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            const result = await this.redis.expire(key, this.TTL_SECONDS + additionalSeconds);
+            return result === 1;
+        }
+        catch (error) {
+            this.logger.error(`Failed to extend TTL for pending customer: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Close Redis connection
+     */
+    async disconnect() {
+        await this.redis.quit();
+    }
+}
+exports.LineRedisHelper = LineRedisHelper;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -6,11 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/framework/utils");
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const crypto_1 = __importDefault(require("crypto"));
+const redis_helper_1 = require("./redis-helper");
 class LineProviderService extends utils_1.AbstractAuthModuleProvider {
-    constructor({ logger }, options) {
+    constructor(dependencies, options) {
         super();
-        this.logger_ = logger;
-        this.options_ = options;
+        this.LINE_TOKEN_ENDPOINT = "https://api.line.me/oauth2/v2.1/token";
+        this.LINE_PROFILE_ENDPOINT = "https://api.line.me/v2/profile";
+        this.logger_ = dependencies.logger;
+        this.options_ = {
+            autoCreateCustomer: true,
+            syncProfileData: true,
+            storeUnlinkedInRedis: true,
+            ...options,
+        };
+        // Initialize Redis helper if Redis URL is provided
+        if (this.options_.redisUrl && this.options_.storeUnlinkedInRedis) {
+            this.redisHelper = new redis_helper_1.LineRedisHelper(this.options_.redisUrl, this.logger_);
+        }
     }
     static validateOptions(options) {
         if (!options.lineChannelId) {
@@ -19,11 +31,8 @@ class LineProviderService extends utils_1.AbstractAuthModuleProvider {
         if (!options.lineChannelSecret) {
             throw new Error("line channel secret is required");
         }
-        if (!options.lineChannelId) {
-            throw new Error("redirect url is required");
-        }
     }
-    async register(data, authIdentityService) {
+    async register(_data, _authIdentityService) {
         throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Line does not support registration. Use method `authenticate` instead.");
     }
     async authenticate(data, authIdentityService) {
@@ -36,16 +45,19 @@ class LineProviderService extends utils_1.AbstractAuthModuleProvider {
             };
         }
         const stateKey = crypto_1.default.randomBytes(32).toString("hex");
+        // Use Medusa's native callback URL pattern
+        const baseUrl = body?.callback_url;
         const state = {
-            callback_url: body?.callback_url ?? this.options_.lineRedirectUrl,
+            callback_url: baseUrl,
         };
         await authIdentityService.setState(stateKey, state);
-        return this.getRedirect(this.options_.lineChannelId, state.callback_url, stateKey);
+        return this.getRedirect(this.options_.lineChannelId, baseUrl, stateKey);
     }
     async validateCallback(req, authIdentityService) {
         const query = req.query ?? {};
         const body = req.body ?? {};
         if (query.error) {
+            this.logger_.error(`LINE OAuth error: ${query.error} - ${query.error_description} - ${query.error_uri} - state: ${query.state}`);
             return {
                 success: false,
                 error: `${query.error_description}, read more at: ${query.error_uri}`,
@@ -53,88 +65,220 @@ class LineProviderService extends utils_1.AbstractAuthModuleProvider {
         }
         const code = query?.code ?? body?.code;
         if (!code) {
-            return { success: false, error: "No code provided" };
+            this.logger_.error(`LINE callback validation failed: No authorization code provided - query: ${JSON.stringify(query)} - body: ${JSON.stringify(body)}`);
+            return { success: false, error: "No authorization code provided" };
         }
-        const state = await authIdentityService.getState(query?.state);
+        const stateKey = query?.state ?? body?.state;
+        if (!stateKey) {
+            this.logger_.error(`LINE callback validation failed: No state parameter provided - code: ${code ? "present" : "missing"}`);
+            return { success: false, error: "No state parameter provided" };
+        }
+        const state = await authIdentityService.getState(stateKey);
         if (!state) {
-            return { success: false, error: "No state provided, or session expired" };
+            this.logger_.error(`LINE callback validation failed: Invalid state or session expired - stateKey: ${stateKey}`);
+            return { success: false, error: "Invalid state or session expired" };
         }
         try {
-            const response = await fetch("https://api.line.me/oauth2/v2.1/token", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                },
-                body: new URLSearchParams({
-                    grant_type: "authorization_code",
-                    code: code,
-                    client_id: this.options_.lineChannelId,
-                    client_secret: this.options_.lineChannelSecret,
-                    redirect_uri: state.callback_url,
-                }),
-            }).then((r) => {
-                if (!r.ok) {
-                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Could not exchange token, ${r.status}, ${r.statusText}`);
-                }
-                return r.json();
-            });
-            const { authIdentity, success } = await this.verify_(response.id_token, authIdentityService);
+            this.logger_.info(`Starting LINE token exchange - hasCode: ${!!code}, hasState: ${!!stateKey}`);
+            const tokenResponse = await this.exchangeCodeForTokens(code, state.callback_url);
+            this.logger_.info("LINE token exchange successful, verifying ID token");
+            const idTokenPayload = await this.verifyIdToken(tokenResponse.id_token);
+            this.logger_.info("ID token verified, fetching user profile");
+            const profile = await this.fetchUserProfile(tokenResponse.access_token);
+            this.logger_.info(`LINE user profile fetched successfully - userId: ${profile.userId}, displayName: ${profile.displayName}, hasEmail: ${!!idTokenPayload.email}`);
+            const { authIdentity } = await this.findOrCreateAuthIdentity(idTokenPayload, profile, tokenResponse, authIdentityService);
+            // Store in Redis using auth_identity_id as key for easy retrieval
+            if (this.redisHelper && !authIdentity.app_metadata?.customer_id) {
+                await this.redisHelper.storePendingCustomer(authIdentity.id, {
+                    line_user_id: profile.userId,
+                    email: idTokenPayload.email,
+                    display_name: profile.displayName,
+                    picture_url: profile.pictureUrl,
+                    status_message: profile.statusMessage,
+                    name: idTokenPayload.name,
+                    auth_identity_id: authIdentity.id,
+                });
+                this.logger_.info(`Stored pending customer in Redis with auth_id: ${authIdentity.id}`);
+            }
             return {
-                success,
+                success: true,
                 authIdentity,
             };
         }
         catch (error) {
-            return { success: false, error: error.message };
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            this.logger_.error(`LINE callback validation failed: ${errorMessage} - code: ${code ? "present" : "missing"}, state: ${stateKey ? "present" : "missing"}, stack: ${errorStack}`);
+            return { success: false, error: errorMessage };
         }
     }
-    async verify_(idToken, authIdentityService) {
-        if (!idToken) {
-            return { success: false, error: "No ID found" };
+    async exchangeCodeForTokens(code, redirectUri) {
+        const response = await fetch(this.LINE_TOKEN_ENDPOINT, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: new URLSearchParams({
+                grant_type: "authorization_code",
+                code: code,
+                client_id: this.options_.lineChannelId,
+                client_secret: this.options_.lineChannelSecret,
+                redirect_uri: redirectUri,
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.text();
+            this.logger_.error(`LINE token exchange failed - status: ${response.status}, statusText: ${response.statusText}, errorData: ${errorData}, clientId: ${this.options_.lineChannelId}`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to exchange authorization code: ${response.status} ${errorData}`);
+        }
+        return response.json();
+    }
+    async verifyIdToken(idToken) {
+        const decoded = jsonwebtoken_1.default.decode(idToken, { complete: true });
+        if (!decoded) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Failed to decode ID token");
+        }
+        const payload = decoded.payload;
+        if (payload.aud !== this.options_.lineChannelId) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token audience mismatch");
+        }
+        if (payload.iss !== "https://access.line.me") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token issuer mismatch");
         }
-        const jwtData = jsonwebtoken_1.default.decode(idToken, {
-            complete: true,
+        const now = Math.floor(Date.now() / 1000);
+        if (payload.exp < now) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token has expired");
+        }
+        return payload;
+    }
+    async fetchUserProfile(accessToken) {
+        const response = await fetch(this.LINE_PROFILE_ENDPOINT, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
         });
-        const payload = jwtData.payload;
-        const entity_id = payload.sub;
+        if (!response.ok) {
+            const errorData = await response.text();
+            this.logger_.error(`Failed to fetch LINE profile - status: ${response.status}, statusText: ${response.statusText}, errorData: ${errorData}`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to fetch LINE profile: ${response.status} ${errorData}`);
+        }
+        return response.json();
+    }
+    async findOrCreateAuthIdentity(idTokenPayload, profile, tokenResponse, authIdentityService) {
+        const entity_id = profile.userId;
         const userMetadata = {
-            name: payload.name,
-            picture: payload.picture,
+            // New format for consistency
+            userId: profile.userId,
+            displayName: profile.displayName,
+            pictureUrl: profile.pictureUrl,
+            // Legacy format for backwards compatibility
+            line_user_id: profile.userId,
+            display_name: profile.displayName,
+            picture_url: profile.pictureUrl,
+            status_message: profile.statusMessage,
+            email: idTokenPayload.email,
+            name: idTokenPayload.name || profile.displayName,
+            picture: idTokenPayload.picture || profile.pictureUrl,
+            first_name: (idTokenPayload.name || profile.displayName || "").split(" ")[0] ||
+                profile.displayName,
+            last_name: (idTokenPayload.name || profile.displayName || "")
+                .split(" ")
+                .slice(1)
+                .join(" ") || "",
+            needs_customer_creation: this.options_.autoCreateCustomer,
+        };
+        // Store tokens in provider metadata for potential later use
+        const providerMetadata = {
+            access_token: tokenResponse.access_token,
+            refresh_token: tokenResponse.refresh_token,
+            expires_in: tokenResponse.expires_in,
+            token_type: tokenResponse.token_type,
+            scope: tokenResponse.scope,
         };
         let authIdentity;
         try {
-            authIdentity = await authIdentityService.retrieve({
-                entity_id,
+            authIdentity = await authIdentityService.retrieve({ entity_id });
+            authIdentity = await authIdentityService.update(entity_id, {
+                user_metadata: userMetadata,
+                provider_metadata: providerMetadata,
             });
         }
         catch (error) {
             if (error.type === utils_1.MedusaError.Types.NOT_FOUND) {
-                const createdAuthIdentity = await authIdentityService.create({
+                this.logger_.info(`Creating new auth identity for LINE user - entity_id: ${entity_id}, displayName: ${userMetadata.display_name}, email: ${userMetadata.email || `line_${entity_id}@line.me`}`);
+                authIdentity = await authIdentityService.create({
                     entity_id,
                     user_metadata: userMetadata,
+                    provider_metadata: providerMetadata,
                 });
-                authIdentity = createdAuthIdentity;
+                this.logger_.info(`Auth identity created successfully - authIdentityId: ${authIdentity.id}, entity_id: ${entity_id}`);
             }
             else {
-                return { success: false, error: error.message };
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger_.error(`Failed to find or create auth identity - error: ${errorMessage}, entity_id: ${entity_id}`);
+                throw error;
             }
         }
-        return {
-            success: true,
-            authIdentity,
-        };
+        return { authIdentity };
+    }
+    async refreshToken(refreshToken) {
+        try {
+            const response = await fetch(this.LINE_TOKEN_ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({
+                    grant_type: "refresh_token",
+                    refresh_token: refreshToken,
+                    client_id: this.options_.lineChannelId,
+                    client_secret: this.options_.lineChannelSecret,
+                }),
+            });
+            if (!response.ok) {
+                this.logger_.error(`Failed to refresh LINE token: ${response.status}`);
+                return null;
+            }
+            return response.json();
+        }
+        catch (error) {
+            this.logger_.error("Error refreshing LINE token:", error);
+            return null;
+        }
+    }
+    async revokeToken(accessToken) {
+        try {
+            const response = await fetch("https://api.line.me/oauth2/v2.1/revoke", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({
+                    access_token: accessToken,
+                    client_id: this.options_.lineChannelId,
+                    client_secret: this.options_.lineChannelSecret,
+                }),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            this.logger_.error("Error revoking LINE token:", error);
+            return false;
+        }
     }
     getRedirect(clientId, callbackUrl, stateKey) {
+        const nonce = crypto_1.default.randomBytes(16).toString("hex");
         const authUrl = new URL(`https://access.line.me/oauth2/v2.1/authorize`);
         authUrl.searchParams.set("response_type", "code");
-        authUrl.searchParams.set("scope", "profile openid");
+        authUrl.searchParams.set("scope", "profile openid email");
         authUrl.searchParams.set("client_id", clientId);
         authUrl.searchParams.set("redirect_uri", callbackUrl);
         authUrl.searchParams.set("state", stateKey);
+        authUrl.searchParams.set("nonce", nonce);
         return { success: true, location: authUrl.toString() };
     }
 }
 LineProviderService.identifier = "line";
 LineProviderService.DISPLAY_NAME = "LINE";
 exports.default = LineProviderService;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/providers/line/service.ts"],"names":[],"mappings":"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"}

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

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

package/.medusa/server/src/providers/line/utils.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+exports.generateState = generateState;
+exports.generateNonce = generateNonce;
+exports.generatePlaceholderEmail = generatePlaceholderEmail;
+exports.parseDisplayName = parseDisplayName;
+exports.validateChannelId = validateChannelId;
+exports.validateCallbackUrl = validateCallbackUrl;
+exports.sanitizeInput = sanitizeInput;
+exports.createAuditLog = createAuditLog;
+exports.handleLineApiError = handleLineApiError;
+const crypto_1 = __importDefault(require("crypto"));
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Generates a secure state parameter for OAuth flow
+ */
+function generateState() {
+    return crypto_1.default.randomBytes(32).toString("hex");
+}
+/**
+ * Generates a nonce for ID token validation
+ */
+function generateNonce() {
+    return crypto_1.default.randomBytes(16).toString("hex");
+}
+/**
+ * Creates a placeholder email for LINE users without email
+ */
+function generatePlaceholderEmail(lineUserId, domain = "line.local") {
+    return `line-${lineUserId}@${domain}`;
+}
+/**
+ * Extracts first and last name from display name
+ */
+function parseDisplayName(displayName) {
+    const parts = displayName.trim().split(" ");
+    const firstName = parts[0] || "";
+    const lastName = parts.slice(1).join(" ") || "";
+    return { firstName, lastName };
+}
+/**
+ * Validates LINE Channel ID format
+ */
+function validateChannelId(channelId) {
+    return /^\d{10}$/.test(channelId);
+}
+/**
+ * Validates callback URL
+ */
+function validateCallbackUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "https:" || parsed.hostname === "localhost";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Rate limit tracker for API calls
+ */
+class RateLimiter {
+    constructor(maxAttempts = 10, windowMs = 60000) {
+        this.attempts = new Map();
+        this.maxAttempts = maxAttempts;
+        this.windowMs = windowMs;
+    }
+    isAllowed(key) {
+        const now = Date.now();
+        const attempts = this.attempts.get(key) || [];
+        // Remove expired attempts
+        const validAttempts = attempts.filter((timestamp) => now - timestamp < this.windowMs);
+        if (validAttempts.length >= this.maxAttempts) {
+            return false;
+        }
+        validAttempts.push(now);
+        this.attempts.set(key, validAttempts);
+        return true;
+    }
+    reset(key) {
+        this.attempts.delete(key);
+    }
+}
+exports.RateLimiter = RateLimiter;
+/**
+ * Sanitizes user input to prevent injection attacks
+ */
+function sanitizeInput(input) {
+    return input
+        .replace(/[<>]/g, "")
+        .replace(/javascript:/gi, "")
+        .trim();
+}
+function createAuditLog(entry) {
+    return {
+        ...entry,
+        timestamp: new Date(),
+    };
+}
+/**
+ * Handles LINE API errors
+ */
+function handleLineApiError(status, message) {
+    const errorMessages = {
+        400: "Invalid request to LINE API",
+        401: "LINE authentication failed",
+        403: "Access forbidden by LINE",
+        429: "Too many requests to LINE API",
+        500: "LINE server error",
+        503: "LINE service temporarily unavailable",
+    };
+    const errorMessage = errorMessages[status] || `LINE API error: ${status}`;
+    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `${errorMessage}: ${message}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lodashventure/medusa-login-provider",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "A starter for Medusa plugins.",
   "author": "Medusa (https://medusajs.com)",
   "license": "MIT",
@@ -13,7 +13,9 @@
     "./.medusa/server/src/modules/*": "./.medusa/server/src/modules/*/index.js",
     "./modules/*": "./.medusa/server/src/modules/*/index.js",
     "./providers/*": "./.medusa/server/src/providers/*/index.js",
-    "./*": "./.medusa/server/src/*.js"
+    "./providers/line": "./.medusa/server/src/providers/line/index.js",
+    "./*": "./.medusa/server/src/*.js",
+    ".": "./.medusa/server/src/index.js"
   },
   "keywords": [
     "medusa",
@@ -24,7 +26,16 @@
   ],
   "scripts": {
     "build": "medusa plugin:build",
-    "dev": "medusa plugin:develop"
+    "dev": "medusa plugin:develop",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false",
+    "test:unit": "jest src/**/*.test.ts --testPathIgnorePatterns=e2e",
+    "test:integration": "jest src/api/__tests__/**/*.test.ts",
+    "test:e2e": "jest src/__tests__/e2e/**/*.test.ts",
+    "lint": "eslint src --ext .ts --fix",
+    "type-check": "tsc --noEmit"
   },
   "devDependencies": {
     "@medusajs/admin-sdk": "2.10.0",
@@ -40,15 +51,25 @@
     "@mikro-orm/migrations": "6.4.3",
     "@mikro-orm/postgresql": "6.4.3",
     "@swc/core": "1.5.7",
+    "@types/jest": "^29.5.0",
     "@types/jsonwebtoken": "^9",
     "@types/node": "^20.0.0",
     "@types/react": "^18.3.2",
     "@types/react-dom": "^18.2.25",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
     "awilix": "^8.0.1",
+    "eslint": "^8.40.0",
+    "jest": "^29.5.0",
+    "jest-junit": "^16.0.0",
+    "jest-watch-typeahead": "^2.2.2",
+    "node-fetch": "^3.3.1",
     "pg": "^8.13.0",
     "prop-types": "^15.8.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
+    "reflect-metadata": "^0.1.13",
+    "ts-jest": "^29.1.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.2",
     "vite": "^5.2.11",
@@ -74,6 +95,8 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@types/ioredis": "^4.28.10",
+    "ioredis": "^5.8.0",
     "jsonwebtoken": "^9.0.2"
   }
 }