mumz-strapi-plugin-coupon 1.0.7

package/dist/services/coupon.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_MESSAGES = exports.ERROR_CODES = void 0;
+const validators_1 = require("../utils/validators");
+// Error codes as per specification
+exports.ERROR_CODES = {
+    COUPON_NOT_FOUND: 'COUPON_NOT_FOUND',
+    COUPON_EXPIRED: 'COUPON_EXPIRED',
+    COUPON_ALREADY_USED: 'COUPON_ALREADY_USED',
+    USAGE_LIMIT_REACHED: 'USAGE_LIMIT_REACHED',
+    INVALID_REQUEST: 'INVALID_REQUEST',
+};
+exports.ERROR_MESSAGES = {
+    COUPON_NOT_FOUND: 'Coupon code does not exist.',
+    COUPON_EXPIRED: 'This coupon has expired.',
+    COUPON_ALREADY_USED: 'This coupon has been already used.',
+    USAGE_LIMIT_REACHED: 'Coupon usage limit has been reached.',
+    INVALID_REQUEST: 'Invalid request parameters.',
+};
+const couponService = ({ strapi }) => ({
+    /**
+     * Validate a coupon for a specific service and user
+     */
+    async validate(params) {
+        const { couponCode, phoneNumber, orderAmount = 0 } = params;
+        try {
+            // Validate inputs
+            if (!(0, validators_1.validateCouponCode)(couponCode)) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.INVALID_REQUEST,
+                    message: 'Invalid coupon code format',
+                };
+            }
+            if (!(0, validators_1.validatePhoneNumber)(phoneNumber)) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.INVALID_REQUEST,
+                    message: 'Invalid phone number format',
+                };
+            }
+            if (orderAmount < 0) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.INVALID_REQUEST,
+                    message: 'Order amount cannot be negative',
+                };
+            }
+            // Find the coupon by code
+            const coupons = await strapi.entityService.findMany('plugin::coupon.coupon', {
+                filters: {
+                    code: couponCode,
+                },
+            });
+            const coupon = Array.isArray(coupons) && coupons.length > 0 ? coupons[0] : null;
+            // Check if coupon exists
+            if (!coupon) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.COUPON_NOT_FOUND,
+                    message: exports.ERROR_MESSAGES.COUPON_NOT_FOUND,
+                };
+            }
+            // Check if coupon is active
+            if (!coupon.isActive) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.COUPON_EXPIRED,
+                    message: exports.ERROR_MESSAGES.COUPON_EXPIRED,
+                };
+            }
+            // Check validity period
+            const now = new Date();
+            const validFrom = new Date(coupon.validFrom);
+            const validTo = new Date(coupon.validTo);
+            if (now < validFrom || now > validTo) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.COUPON_EXPIRED,
+                    message: exports.ERROR_MESSAGES.COUPON_EXPIRED,
+                };
+            }
+            // Check usage limit
+            if (coupon.maxUsage && coupon.currentUsage >= coupon.maxUsage) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.USAGE_LIMIT_REACHED,
+                    message: exports.ERROR_MESSAGES.USAGE_LIMIT_REACHED,
+                };
+            }
+            // Check if user has already used this coupon
+            const existingRedemptions = await strapi.entityService.findMany('plugin::coupon.redemption', {
+                filters: {
+                    coupon: coupon.id,
+                    phoneNumber,
+                },
+            });
+            if (Array.isArray(existingRedemptions) && existingRedemptions.length > 0) {
+                return {
+                    isValid: false,
+                    errorCode: exports.ERROR_CODES.COUPON_ALREADY_USED,
+                    message: exports.ERROR_MESSAGES.COUPON_ALREADY_USED,
+                };
+            }
+            // Calculate discount
+            let discountAmount = 0;
+            let finalAmount = orderAmount;
+            if (coupon.discountType === 'percentage') {
+                discountAmount = (orderAmount * coupon.discountValue) / 100;
+                finalAmount = orderAmount - discountAmount;
+            }
+            else if (coupon.discountType === 'flat') {
+                discountAmount = coupon.discountValue;
+                finalAmount = Math.max(0, orderAmount - discountAmount);
+            }
+            // Return valid response
+            return {
+                isValid: true,
+                discountType: coupon.discountType,
+                discountValue: coupon.discountValue,
+                discountAmount,
+                finalAmount,
+                message: 'Coupon applied successfully.',
+            };
+        }
+        catch (error) {
+            strapi.log.error('Error validating coupon:', error);
+            throw error;
+        }
+    },
+    /**
+     * Redeem a coupon after successful payment
+     * Uses database transaction to prevent race conditions
+     */
+    async redeem(params) {
+        const { couponCode, phoneNumber, orderId, orderAmount = 0 } = params;
+        try {
+            // Validate inputs
+            if (!(0, validators_1.validateOrderId)(orderId)) {
+                return {
+                    success: false,
+                    errorCode: exports.ERROR_CODES.INVALID_REQUEST,
+                    message: 'Invalid order ID format',
+                };
+            }
+            // Find and validate the coupon
+            const coupons = await strapi.db.query('plugin::coupon.coupon').findMany({
+                where: { code: couponCode },
+            });
+            const coupon = Array.isArray(coupons) && coupons.length > 0 ? coupons[0] : null;
+            if (!coupon) {
+                return {
+                    success: false,
+                    errorCode: exports.ERROR_CODES.COUPON_NOT_FOUND,
+                    message: exports.ERROR_MESSAGES.COUPON_NOT_FOUND,
+                };
+            }
+            // Validate phone number
+            if (!(0, validators_1.validatePhoneNumber)(phoneNumber)) {
+                return {
+                    success: false,
+                    errorCode: exports.ERROR_CODES.INVALID_REQUEST,
+                    message: 'Invalid phone number format',
+                };
+            }
+            // Perform all validations
+            if (!coupon.isActive) {
+                return {
+                    success: false,
+                    errorCode: exports.ERROR_CODES.COUPON_EXPIRED,
+                    message: exports.ERROR_MESSAGES.COUPON_EXPIRED,
+                };
+            }
+            const now = new Date();
+            const validFrom = new Date(coupon.validFrom);
+            const validTo = new Date(coupon.validTo);
+            if (now < validFrom || now > validTo) {
+                return {
+                    success: false,
+                    errorCode: exports.ERROR_CODES.COUPON_EXPIRED,
+                    message: exports.ERROR_MESSAGES.COUPON_EXPIRED,
+                };
+            }
+            // Check for existing redemption
+            const existingRedemptions = await strapi.db.query('plugin::coupon.redemption').findMany({
+                where: {
+                    coupon: coupon.id,
+                    phoneNumber,
+                },
+            });
+            if (Array.isArray(existingRedemptions) && existingRedemptions.length > 0) {
+                return {
+                    success: false,
+                    errorCode: exports.ERROR_CODES.COUPON_ALREADY_USED,
+                    message: exports.ERROR_MESSAGES.COUPON_ALREADY_USED,
+                };
+            }
+            // Check usage limit before attempting redemption
+            if (coupon.maxUsage && coupon.currentUsage >= coupon.maxUsage) {
+                return {
+                    success: false,
+                    errorCode: exports.ERROR_CODES.USAGE_LIMIT_REACHED,
+                    message: exports.ERROR_MESSAGES.USAGE_LIMIT_REACHED,
+                };
+            }
+            // Calculate discount
+            let discountAmount = 0;
+            let finalAmount = orderAmount;
+            if (coupon.discountType === 'percentage') {
+                discountAmount = (orderAmount * coupon.discountValue) / 100;
+                finalAmount = orderAmount - discountAmount;
+            }
+            else if (coupon.discountType === 'flat') {
+                discountAmount = coupon.discountValue;
+                finalAmount = Math.max(0, orderAmount - discountAmount);
+            }
+            // Use transaction for atomic redemption
+            let redemptionId;
+            try {
+                // Atomic increment with optimistic locking
+                const updateResult = await strapi.db.query('plugin::coupon.coupon').update({
+                    where: {
+                        id: coupon.id,
+                        currentUsage: coupon.currentUsage, // Optimistic lock
+                    },
+                    data: {
+                        currentUsage: coupon.currentUsage + 1,
+                    },
+                });
+                // If update failed due to concurrent modification, check usage limit
+                if (!updateResult || (coupon.maxUsage && coupon.currentUsage + 1 > coupon.maxUsage)) {
+                    return {
+                        success: false,
+                        errorCode: exports.ERROR_CODES.USAGE_LIMIT_REACHED,
+                        message: exports.ERROR_MESSAGES.USAGE_LIMIT_REACHED,
+                    };
+                }
+                // Create redemption record
+                const redemption = await strapi.db.query('plugin::coupon.redemption').create({
+                    data: {
+                        coupon: coupon.id,
+                        phoneNumber,
+                        orderId,
+                        discountType: coupon.discountType,
+                        discountValue: coupon.discountValue,
+                        redemptionDate: new Date(),
+                        metadata: {
+                            orderAmount,
+                            finalAmount,
+                            discountAmount,
+                        },
+                    },
+                });
+                redemptionId = `redeem_${redemption.id}`;
+            }
+            catch (error) {
+                strapi.log.error('Transaction error during redemption:', error);
+                throw error;
+            }
+            return {
+                success: true,
+                message: 'Coupon redeemed successfully.',
+                redemptionId,
+            };
+        }
+        catch (error) {
+            strapi.log.error('Error redeeming coupon:', error);
+            throw error;
+        }
+    },
+    /**
+     * Create a new coupon (Admin only)
+     */
+    async create(params) {
+        try {
+            const { code, discountType, discountValue, maxUsage, validFrom, validTo, description, userRestrictions, } = params;
+            // Validate coupon code
+            if (!(0, validators_1.validateCouponCode)(code)) {
+                return {
+                    success: false,
+                    errorCode: 'INVALID_COUPON_CODE',
+                    message: 'Coupon code must be 3-50 uppercase alphanumeric characters',
+                };
+            }
+            // Validate discount value
+            const discountValidation = (0, validators_1.validateDiscountValue)(discountType, discountValue);
+            if (!discountValidation.valid) {
+                return {
+                    success: false,
+                    errorCode: 'INVALID_DISCOUNT',
+                    message: discountValidation.error || 'Invalid discount value',
+                };
+            }
+            // Validate date range
+            const dateValidation = (0, validators_1.validateDateRange)(validFrom, validTo);
+            if (!dateValidation.valid) {
+                return {
+                    success: false,
+                    errorCode: 'INVALID_DATE_RANGE',
+                    message: dateValidation.error || 'Invalid date range',
+                };
+            }
+            // Validate maxUsage
+            if (maxUsage !== undefined && (typeof maxUsage !== 'number' || maxUsage < 1)) {
+                return {
+                    success: false,
+                    errorCode: 'INVALID_MAX_USAGE',
+                    message: 'maxUsage must be a positive number',
+                };
+            }
+            // Check if coupon code already exists
+            const existingCoupons = await strapi.entityService.findMany('plugin::coupon.coupon', {
+                filters: {
+                    code,
+                },
+            });
+            if (Array.isArray(existingCoupons) && existingCoupons.length > 0) {
+                return {
+                    success: false,
+                    errorCode: 'COUPON_ALREADY_EXISTS',
+                    message: 'A coupon with this code already exists.',
+                };
+            }
+            // Create the coupon
+            const coupon = await strapi.entityService.create('plugin::coupon.coupon', {
+                data: {
+                    code,
+                    discountType,
+                    discountValue,
+                    maxUsage: maxUsage || null,
+                    currentUsage: 0,
+                    validFrom,
+                    validTo,
+                    isActive: true,
+                    description: description || null,
+                    userRestrictions: userRestrictions || null,
+                },
+            });
+            return {
+                success: true,
+                couponId: `coupon_${coupon.id}`,
+                message: 'Coupon created successfully.',
+            };
+        }
+        catch (error) {
+            strapi.log.error('Error creating coupon:', error);
+            throw error;
+        }
+    },
+    /**
+     * Get all coupons
+     */
+    async findAll(query = {}) {
+        try {
+            return await strapi.entityService.findMany('plugin::coupon.coupon', query);
+        }
+        catch (error) {
+            strapi.log.error('Error finding coupons:', error);
+            throw error;
+        }
+    },
+    /**
+     * Get a single coupon
+     */
+    async findOne(id) {
+        try {
+            return await strapi.entityService.findOne('plugin::coupon.coupon', id);
+        }
+        catch (error) {
+            strapi.log.error('Error finding coupon:', error);
+            throw error;
+        }
+    },
+    /**
+     * Update a coupon
+     */
+    async update(id, data) {
+        try {
+            return await strapi.entityService.update('plugin::coupon.coupon', id, { data });
+        }
+        catch (error) {
+            strapi.log.error('Error updating coupon:', error);
+            throw error;
+        }
+    },
+    /**
+     * Delete a coupon
+     */
+    async delete(id) {
+        try {
+            return await strapi.entityService.delete('plugin::coupon.coupon', id);
+        }
+        catch (error) {
+            strapi.log.error('Error deleting coupon:', error);
+            throw error;
+        }
+    },
+});
+exports.default = couponService;

package/dist/services/index.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const _default: Record<string, (params: {
+    strapi: Core.Strapi;
+}) => any>;
+export default _default;

package/dist/services/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const coupon_1 = __importDefault(require("./coupon"));
+exports.default = {
+    coupon: coupon_1.default,
+};

package/dist/utils/validators.d.ts

@@ -0,0 +1,14 @@
+export declare const PHONE_REGEX: RegExp;
+export declare const ORDER_ID_REGEX: RegExp;
+export declare const COUPON_CODE_REGEX: RegExp;
+export declare function validatePhoneNumber(phone: string): boolean;
+export declare function validateOrderId(orderId: string): boolean;
+export declare function validateCouponCode(code: string): boolean;
+export declare function validateDiscountValue(discountType: string, discountValue: number): {
+    valid: boolean;
+    error?: string;
+};
+export declare function validateDateRange(validFrom: string, validTo: string): {
+    valid: boolean;
+    error?: string;
+};

package/dist/utils/validators.js

@@ -0,0 +1,41 @@
+"use strict";
+// Input validation utilities
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COUPON_CODE_REGEX = exports.ORDER_ID_REGEX = exports.PHONE_REGEX = void 0;
+exports.validatePhoneNumber = validatePhoneNumber;
+exports.validateOrderId = validateOrderId;
+exports.validateCouponCode = validateCouponCode;
+exports.validateDiscountValue = validateDiscountValue;
+exports.validateDateRange = validateDateRange;
+exports.PHONE_REGEX = /^\+?[1-9]\d{1,14}$/; // E.164 format
+exports.ORDER_ID_REGEX = /^[a-zA-Z0-9_-]{1,100}$/;
+exports.COUPON_CODE_REGEX = /^[A-Z0-9]{3,50}$/;
+function validatePhoneNumber(phone) {
+    return typeof phone === 'string' && phone.length >= 10 && phone.length <= 15 && exports.PHONE_REGEX.test(phone);
+}
+function validateOrderId(orderId) {
+    return typeof orderId === 'string' && orderId.length >= 1 && orderId.length <= 100 && exports.ORDER_ID_REGEX.test(orderId);
+}
+function validateCouponCode(code) {
+    return typeof code === 'string' && code.length >= 3 && code.length <= 50 && exports.COUPON_CODE_REGEX.test(code);
+}
+function validateDiscountValue(discountType, discountValue) {
+    if (typeof discountValue !== 'number' || discountValue <= 0) {
+        return { valid: false, error: 'Discount value must be greater than 0' };
+    }
+    if (discountType === 'percentage' && discountValue > 100) {
+        return { valid: false, error: 'Percentage discount cannot exceed 100%' };
+    }
+    return { valid: true };
+}
+function validateDateRange(validFrom, validTo) {
+    const validFromDate = new Date(validFrom);
+    const validToDate = new Date(validTo);
+    if (isNaN(validFromDate.getTime()) || isNaN(validToDate.getTime())) {
+        return { valid: false, error: 'Invalid date format' };
+    }
+    if (validFromDate >= validToDate) {
+        return { valid: false, error: 'validFrom must be before validTo' };
+    }
+    return { valid: true };
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "mumz-strapi-plugin-coupon",
+  "version": "1.0.7",
+  "description": "Strapi plugin for centralized coupon management across multiple services",
+  "strapi": {
+    "name": "coupon",
+    "displayName": "Coupon Management",
+    "description": "Centralized coupon management system for validation, redemption, and tracking",
+    "kind": "plugin"
+  },
+  "keywords": [
+    "strapi",
+    "plugin",
+    "coupon",
+    "discount",
+    "promotion"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Mumzworld Tech"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mumzworld-tech/strapi-plugin-coupon.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mumzworld-tech/strapi-plugin-coupon/issues"
+  },
+  "homepage": "https://github.com/mumzworld-tech/strapi-plugin-coupon#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "clean": "rimraf dist",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "type-check": "tsc --noEmit"
+  },
+  "main": "./strapi-server.js",
+  "exports": {
+    "./strapi-server": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "strapi-admin.js",
+    "strapi-server.js"
+  ],
+  "dependencies": {
+    "typescript": "^5.0.0",
+    "rimraf": "^5.0.0"
+  },
+  "devDependencies": {
+    "@strapi/strapi": "^5.0.0",
+    "@strapi/typescript-utils": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "peerDependencies": {
+    "@strapi/strapi": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=6.0.0"
+  }
+}

package/strapi-server.js

@@ -0,0 +1 @@
+module.exports = require('./dist').default;