mumz-strapi-plugin-coupon 1.0.7 → 1.1.1

package/README.md

@@ -1,311 +1,22 @@
-# Strapi Plugin - Coupon Management
-
+#Strapi Plugin - Coupon Management
 A centralized coupon management system for Strapi that handles validation, redemption, and tracking across multiple service domains.
 
 ## Requirements
-
 - Strapi 5.0.0 or higher
 - Node.js 18.0.0 or higher
 - npm 6.0.0 or higher
 - PostgreSQL, MySQL, or SQLite
 
 ## Features
-
-- ✅ Centralized coupon creation and management
-- ✅ Cross-domain coupon support (Homecare, Nannies, Gear Refresh, etc.)
-- ✅ Flexible discount types (percentage, flat)
-- ✅ Usage limits and validity periods
-- ✅ User eligibility validation
-- ✅ Service-specific applicability
-- ✅ Complete redemption audit trail
-- ✅ RESTful API endpoints
-- ✅ Race condition protection for concurrent redemptions
-- ✅ Input validation and sanitization
-- ✅ Rate limiting on public endpoints
-- ✅ TypeScript support with full type definitions
-
-## Installation
-
-### Using npm (via GitHub)
-
-```bash
-npm install github:mumzworld-tech/mumz-services-coupons-strapi-plugin
-```
-
-### Using yarn (via GitHub)
-
-```bash
-yarn add github:mumzworld-tech/mumz-services-coupons-strapi-plugin
-```
-
-## Configuration
-
-Add the plugin to your Strapi configuration:
-
-**`config/plugins.js`** or **`config/plugins.ts`**:
-
-```javascript
-module.exports = {
-  'coupon': {
-    enabled: true,
-    resolve: './node_modules/mumz-strapi-plugin-coupon'
-  },
-};
-```
-
-## API Endpoints
-
-### 1. Validate Coupon
-
-**POST** `/api/coupon/validate`
-
-Validates a coupon for a user before applying it.
-
-**Request Body:**
-```json
-{
-  "couponCode": "WELCOME10",
-  "phoneNumber": "+97155XXXXXX",
-  "orderAmount": 250.00
-}
-```
-
-**Success Response:**
-```json
-{
-  "isValid": true,
-  "discountType": "percentage",
-  "discountValue": 10,
-  "discountAmount": 25,
-  "finalAmount": 225.00,
-  "message": "Coupon applied successfully."
-}
-```
-
-**Error Response:**
-```json
-{
-  "isValid": false,
-  "errorCode": "COUPON_EXPIRED",
-  "message": "This coupon has expired."
-}
-```
-
-### 2. Redeem Coupon
-
-**POST** `/api/coupon/redeem`
-
-Marks a coupon as redeemed once successfully applied.
-
-**Request Body:**
-```json
-{
-  "couponCode": "WELCOME10",
-  "phoneNumber": "+97155XXXXXX",
-  "orderId": "order_67890",
-  "orderAmount": 250.00
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Coupon redeemed successfully.",
-  "redemptionId": "redeem_1"
-}
-```
-
-### 3. Create Coupon (No Auth Required)
-
-**POST** `/api/coupon`
-
-Create new coupons. Authentication has been disabled for easier integration.
-
-**Request Body:**
-```json
-{
-  "code": "SUMMER25",
-  "discountType": "flat",
-  "discountValue": 25,
-  "maxUsage": 1000,
-  "validFrom": "2025-05-01T00:00:00Z",
-  "validTo": "2025-06-30T23:59:59Z"
-}
-```
-
-**Response:**
-```json
-{
-  "couponId": "coupon_abc123",
-  "message": "Coupon created successfully."
-}
-```
-
-## Error Codes
-
-| Code | Description |
-|------|-------------|
-| `COUPON_NOT_FOUND` | Coupon code does not exist |
-| `COUPON_EXPIRED` | Coupon validity period has expired |
-| `COUPON_ALREADY_USED` | User has already redeemed this coupon |
-| `USAGE_LIMIT_REACHED` | Coupon usage limit has been reached |
-
-## Quick Start
-
-### 1. Installation
-
-See [INSTALLATION.md](./INSTALLATION.md) for detailed installation instructions.
-
-```bash
-# Install from GitHub
-npm install github:mumzworld-tech/mumz-services-coupons-strapi-plugin#v1.0.0
-
-# Configure in config/plugins.js
-module.exports = {
-  'coupon': {
-    enabled: true,
-    resolve: './node_modules/mumz-strapi-plugin-coupon',
-  },
-};
-
-# Build and start Strapi
-npm run build
-npm run develop
-```
-
-### 2. Verify Installation
-
-Check that the plugin loaded successfully:
-- Admin panel shows **Coupon** and **Redemption** content types
-- Routes are registered: `npx strapi routes:list | grep coupon`
-- See console logs: "Coupon plugin registered" and "Coupon plugin bootstrapped"
-
-### 3. Test the Plugin
-
-See [TESTING.md](./TESTING.md) for comprehensive testing instructions.
-
-```bash
-# Create a test coupon via API
-curl -X POST http://localhost:1337/api/coupon \
-  -H "Content-Type: application/json" \
-  -d '{
-    "code": "WELCOME10",
-    "discountType": "percentage",
-    "discountValue": 10,
-    "maxUsage": 1000,
-    "validFrom": "2025-01-01T00:00:00Z",
-    "validTo": "2025-12-31T23:59:59Z",
-    "description": "Welcome discount - 10% off"
-  }'
-
-# Validate the coupon
-curl -X POST http://localhost:1337/api/coupon/validate \
-  -H "Content-Type: application/json" \
-  -d '{
-    "couponCode": "WELCOME10",
-    "phoneNumber": "+971551234567",
-    "orderAmount": 250.00
-  }'
-```
-
-## Development
-
-### Prerequisites
-
-- Node.js >= 18.x
-- npm >= 6.x
-
-### Setup
-
-```bash
-# Install dependencies
-npm install
-
-# Build the plugin
-npm run build
-
-# Watch mode for development
-npm run watch
-```
-
-### Building for Production
-
-```bash
-npm run clean
-npm run build
-```
-
-## Publishing to GitHub
-
-See [PUBLISHING.md](./PUBLISHING.md) for detailed instructions on publishing this plugin internally via GitHub.
-
-## TypeScript Usage
-
-The plugin is written in TypeScript and provides full type definitions:
-
-```typescript
-import type {
-  ValidateCouponRequest,
-  ValidationResponse,
-  RedeemCouponRequest,
-  RedemptionResponse,
-  CreateCouponRequest,
-  CreateResponse
-} from 'strapi-plugin-coupon/dist/services/coupon';
-
-// Example: Validate a coupon
-const result: ValidationResponse = await strapi
-  .plugin('coupon')
-  .service('coupon')
-  .validate({
-    couponCode: 'WELCOME10',
-    service: 'homecare',
-    phoneNumber: '+971551234567',
-    orderAmount: 250.00,
-  });
-
-if (result.isValid) {
-  console.log(`Discount: ${result.discountAmount}`);
-  console.log(`Final Amount: ${result.finalAmount}`);
-}
-```
-
-## Rate Limiting
-
-The plugin implements rate limiting on public endpoints:
-- `/validate`: 10 requests per minute per IP
-- `/redeem`: 5 requests per minute per IP
-
-The plugin uses in-memory rate limiting which is suitable for single-instance deployments.
-
-## Security Features
-
-- ✅ Input validation on all endpoints
-- ✅ Protection against SQL injection
-- ✅ Race condition prevention using optimistic locking
-- ✅ Phone number validation (E.164 format)
-- ✅ Service and coupon code validation
-- ✅ Rate limiting to prevent abuse
-
-## Troubleshooting
-
-### Build fails with TypeScript errors
-
-Ensure dependencies are installed:
-```bash
-npm install
-npm run build
-```
-
-### Plugin not loading in Strapi
-
-Verify the plugin configuration in `config/plugins.js` and ensure the plugin is properly installed in `node_modules`.
-
-### Rate limit errors (429)
-
-Default rate limits are 10 req/min for validate, 5 req/min for redeem. These can be adjusted in the route configuration.
-
-## License
-
-MIT
+✅ Centralized coupon creation and management
+✅ Cross-domain coupon support (Homecare, Nannies, Gear Refresh, etc.)
+✅ Flexible discount types (percentage, flat)
+✅ Usage limits and validity periods
+✅ User eligibility validation
+✅ Service-specific applicability
+✅ Complete redemption audit trail
+✅ RESTful API endpoints
+✅ Race condition protection for concurrent redemptions
+✅ Input validation and sanitization
+✅ Rate limiting on public endpoints
+✅ TypeScript support with full type definitions

package/dist/content-types/coupon/index.d.ts

@@ -50,6 +50,12 @@ declare const _default: {
                 min: number;
                 default: null;
             };
+            maxUsagePerUser: {
+                type: string;
+                required: boolean;
+                min: number;
+                default: null;
+            };
             currentUsage: {
                 type: string;
                 required: boolean;

package/dist/content-types/coupon/schema.d.ts

@@ -49,6 +49,12 @@ declare const _default: {
             min: number;
             default: null;
         };
+        maxUsagePerUser: {
+            type: string;
+            required: boolean;
+            min: number;
+            default: null;
+        };
         currentUsage: {
             type: string;
             required: boolean;

package/dist/content-types/coupon/schema.js

@@ -21,8 +21,9 @@ exports.default = {
         },
     },
     layouts: {
-        list: ['code', 'discountType', 'discountValue', 'currentUsage', 'maxUsage', 'isActive', 'validFrom', 'validTo'],
+        list: ['code', 'discountType', 'discountValue', 'currentUsage', 'maxUsage', 'maxUsagePerUser', 'isActive', 'validFrom', 'validTo'],
         edit: [
+            // -- Coupon Info --
             [
                 { name: 'code', size: 6 },
                 { name: 'isActive', size: 6 },
@@ -31,15 +32,20 @@ exports.default = {
                 { name: 'discountType', size: 6 },
                 { name: 'discountValue', size: 6 },
             ],
+            // -- Usage Limits --
             [
-                { name: 'maxUsage', size: 6 },
-                { name: 'currentUsage', size: 6 },
+                { name: 'maxUsage', size: 4 },
+                { name: 'maxUsagePerUser', size: 4 },
+                { name: 'currentUsage', size: 4 },
             ],
+            // -- Validity Period --
             [
                 { name: 'validFrom', size: 6 },
                 { name: 'validTo', size: 6 },
             ],
+            // -- Additional Info --
             [{ name: 'description', size: 12 }],
+            // -- Restrictions --
             [{ name: 'userRestrictions', size: 12 }],
         ],
     },
@@ -67,6 +73,12 @@ exports.default = {
             min: 0,
             default: null,
         },
+        maxUsagePerUser: {
+            type: 'integer',
+            required: false,
+            min: 0,
+            default: null,
+        },
         currentUsage: {
             type: 'integer',
             required: true,

package/dist/content-types/index.d.ts

@@ -51,6 +51,12 @@ declare const _default: {
                     min: number;
                     default: null;
                 };
+                maxUsagePerUser: {
+                    type: string;
+                    required: boolean;
+                    min: number;
+                    default: null;
+                };
                 currentUsage: {
                     type: string;
                     required: boolean;

package/dist/index.d.ts

@@ -96,6 +96,12 @@ declare const plugin: {
                         min: number;
                         default: null;
                     };
+                    maxUsagePerUser: {
+                        type: string;
+                        required: boolean;
+                        min: number;
+                        default: null;
+                    };
                     currentUsage: {
                         type: string;
                         required: boolean;

package/dist/services/coupon.d.ts

@@ -1,10 +1,11 @@
-import type { Core } from '@strapi/strapi';
+import type { Core } from "@strapi/strapi";
 export declare const ERROR_CODES: {
     readonly COUPON_NOT_FOUND: "COUPON_NOT_FOUND";
     readonly COUPON_EXPIRED: "COUPON_EXPIRED";
     readonly COUPON_ALREADY_USED: "COUPON_ALREADY_USED";
     readonly USAGE_LIMIT_REACHED: "USAGE_LIMIT_REACHED";
     readonly INVALID_REQUEST: "INVALID_REQUEST";
+    readonly USER_RESTRICTED: "USER_RESTRICTED";
 };
 export declare const ERROR_MESSAGES: {
     readonly COUPON_NOT_FOUND: "Coupon code does not exist.";
@@ -12,6 +13,7 @@ export declare const ERROR_MESSAGES: {
     readonly COUPON_ALREADY_USED: "This coupon has been already used.";
     readonly USAGE_LIMIT_REACHED: "Coupon usage limit has been reached.";
     readonly INVALID_REQUEST: "Invalid request parameters.";
+    readonly USER_RESTRICTED: "This coupon is not available for your phone number.";
 };
 export interface ValidateCouponRequest {
     couponCode: string;
@@ -26,13 +28,14 @@ export interface RedeemCouponRequest {
 }
 export interface CreateCouponRequest {
     code: string;
-    discountType: 'percentage' | 'flat';
+    discountType: "percentage" | "flat";
     discountValue: number;
     maxUsage?: number;
+    maxUsagePerUser?: number;
     validFrom: string;
     validTo: string;
     description?: string;
-    userRestrictions?: any;
+    userRestrictions?: string[];
 }
 export interface ValidationResponse {
     isValid: boolean;

package/dist/services/coupon.js

@@ -4,18 +4,20 @@ 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',
+    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",
+    USER_RESTRICTED: "USER_RESTRICTED",
 };
 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.',
+    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.",
+    USER_RESTRICTED: "This coupon is not available for your phone number.",
 };
 const couponService = ({ strapi }) => ({
     /**
@@ -29,25 +31,25 @@ const couponService = ({ strapi }) => ({
                 return {
                     isValid: false,
                     errorCode: exports.ERROR_CODES.INVALID_REQUEST,
-                    message: 'Invalid coupon code format',
+                    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',
+                    message: "Invalid phone number format",
                 };
             }
             if (orderAmount < 0) {
                 return {
                     isValid: false,
                     errorCode: exports.ERROR_CODES.INVALID_REQUEST,
-                    message: 'Order amount cannot be negative',
+                    message: "Order amount cannot be negative",
                 };
             }
             // Find the coupon by code
-            const coupons = await strapi.entityService.findMany('plugin::coupon.coupon', {
+            const coupons = await strapi.entityService.findMany("plugin::coupon.coupon", {
                 filters: {
                     code: couponCode,
                 },
@@ -88,14 +90,19 @@ const couponService = ({ strapi }) => ({
                     message: exports.ERROR_MESSAGES.USAGE_LIMIT_REACHED,
                 };
             }
-            // Check if user has already used this coupon
-            const existingRedemptions = await strapi.entityService.findMany('plugin::coupon.redemption', {
+            // Check per-user usage limit
+            const existingRedemptions = await strapi.entityService.findMany("plugin::coupon.redemption", {
                 filters: {
                     coupon: coupon.id,
                     phoneNumber,
                 },
             });
-            if (Array.isArray(existingRedemptions) && existingRedemptions.length > 0) {
+            const userRedemptionCount = Array.isArray(existingRedemptions)
+                ? existingRedemptions.length
+                : 0;
+            // maxUsagePerUser: 0 = disabled, null/undefined = 1, N = N uses per user
+            const perUserLimit = coupon.maxUsagePerUser ?? 1;
+            if (perUserLimit === 0 || userRedemptionCount >= perUserLimit) {
                 return {
                     isValid: false,
                     errorCode: exports.ERROR_CODES.COUPON_ALREADY_USED,
@@ -105,11 +112,11 @@ const couponService = ({ strapi }) => ({
             // Calculate discount
             let discountAmount = 0;
             let finalAmount = orderAmount;
-            if (coupon.discountType === 'percentage') {
+            if (coupon.discountType === "percentage") {
                 discountAmount = (orderAmount * coupon.discountValue) / 100;
                 finalAmount = orderAmount - discountAmount;
             }
-            else if (coupon.discountType === 'flat') {
+            else if (coupon.discountType === "flat") {
                 discountAmount = coupon.discountValue;
                 finalAmount = Math.max(0, orderAmount - discountAmount);
             }
@@ -120,11 +127,11 @@ const couponService = ({ strapi }) => ({
                 discountValue: coupon.discountValue,
                 discountAmount,
                 finalAmount,
-                message: 'Coupon applied successfully.',
+                message: "Coupon applied successfully.",
             };
         }
         catch (error) {
-            strapi.log.error('Error validating coupon:', error);
+            strapi.log.error("Error validating coupon:", error);
             throw error;
         }
     },
@@ -140,11 +147,11 @@ const couponService = ({ strapi }) => ({
                 return {
                     success: false,
                     errorCode: exports.ERROR_CODES.INVALID_REQUEST,
-                    message: 'Invalid order ID format',
+                    message: "Invalid order ID format",
                 };
             }
             // Find and validate the coupon
-            const coupons = await strapi.db.query('plugin::coupon.coupon').findMany({
+            const coupons = await strapi.db.query("plugin::coupon.coupon").findMany({
                 where: { code: couponCode },
             });
             const coupon = Array.isArray(coupons) && coupons.length > 0 ? coupons[0] : null;
@@ -160,7 +167,7 @@ const couponService = ({ strapi }) => ({
                 return {
                     success: false,
                     errorCode: exports.ERROR_CODES.INVALID_REQUEST,
-                    message: 'Invalid phone number format',
+                    message: "Invalid phone number format",
                 };
             }
             // Perform all validations
@@ -181,14 +188,31 @@ const couponService = ({ strapi }) => ({
                     message: exports.ERROR_MESSAGES.COUPON_EXPIRED,
                 };
             }
-            // Check for existing redemption
-            const existingRedemptions = await strapi.db.query('plugin::coupon.redemption').findMany({
+            // Check user restrictions (blocked phone numbers)
+            if (coupon.userRestrictions && Array.isArray(coupon.userRestrictions)) {
+                if (coupon.userRestrictions.includes(phoneNumber)) {
+                    return {
+                        success: false,
+                        errorCode: exports.ERROR_CODES.USER_RESTRICTED,
+                        message: exports.ERROR_MESSAGES.USER_RESTRICTED,
+                    };
+                }
+            }
+            // Check per-user usage limit
+            const existingRedemptions = await strapi.db
+                .query("plugin::coupon.redemption")
+                .findMany({
                 where: {
                     coupon: coupon.id,
                     phoneNumber,
                 },
             });
-            if (Array.isArray(existingRedemptions) && existingRedemptions.length > 0) {
+            const userRedemptionCount = Array.isArray(existingRedemptions)
+                ? existingRedemptions.length
+                : 0;
+            // maxUsagePerUser: 0 = disabled, null/undefined = 1, N = N uses per user
+            const perUserLimit = coupon.maxUsagePerUser ?? 1;
+            if (perUserLimit === 0 || userRedemptionCount >= perUserLimit) {
                 return {
                     success: false,
                     errorCode: exports.ERROR_CODES.COUPON_ALREADY_USED,
@@ -206,11 +230,11 @@ const couponService = ({ strapi }) => ({
             // Calculate discount
             let discountAmount = 0;
             let finalAmount = orderAmount;
-            if (coupon.discountType === 'percentage') {
+            if (coupon.discountType === "percentage") {
                 discountAmount = (orderAmount * coupon.discountValue) / 100;
                 finalAmount = orderAmount - discountAmount;
             }
-            else if (coupon.discountType === 'flat') {
+            else if (coupon.discountType === "flat") {
                 discountAmount = coupon.discountValue;
                 finalAmount = Math.max(0, orderAmount - discountAmount);
             }
@@ -218,7 +242,9 @@ const couponService = ({ strapi }) => ({
             let redemptionId;
             try {
                 // Atomic increment with optimistic locking
-                const updateResult = await strapi.db.query('plugin::coupon.coupon').update({
+                const updateResult = await strapi.db
+                    .query("plugin::coupon.coupon")
+                    .update({
                     where: {
                         id: coupon.id,
                         currentUsage: coupon.currentUsage, // Optimistic lock
@@ -228,7 +254,8 @@ const couponService = ({ strapi }) => ({
                     },
                 });
                 // If update failed due to concurrent modification, check usage limit
-                if (!updateResult || (coupon.maxUsage && coupon.currentUsage + 1 > coupon.maxUsage)) {
+                if (!updateResult ||
+                    (coupon.maxUsage && coupon.currentUsage + 1 > coupon.maxUsage)) {
                     return {
                         success: false,
                         errorCode: exports.ERROR_CODES.USAGE_LIMIT_REACHED,
@@ -236,7 +263,9 @@ const couponService = ({ strapi }) => ({
                     };
                 }
                 // Create redemption record
-                const redemption = await strapi.db.query('plugin::coupon.redemption').create({
+                const redemption = await strapi.db
+                    .query("plugin::coupon.redemption")
+                    .create({
                     data: {
                         coupon: coupon.id,
                         phoneNumber,
@@ -254,17 +283,17 @@ const couponService = ({ strapi }) => ({
                 redemptionId = `redeem_${redemption.id}`;
             }
             catch (error) {
-                strapi.log.error('Transaction error during redemption:', error);
+                strapi.log.error("Transaction error during redemption:", error);
                 throw error;
             }
             return {
                 success: true,
-                message: 'Coupon redeemed successfully.',
+                message: "Coupon redeemed successfully.",
                 redemptionId,
             };
         }
         catch (error) {
-            strapi.log.error('Error redeeming coupon:', error);
+            strapi.log.error("Error redeeming coupon:", error);
             throw error;
         }
     },
@@ -273,13 +302,13 @@ const couponService = ({ strapi }) => ({
      */
     async create(params) {
         try {
-            const { code, discountType, discountValue, maxUsage, validFrom, validTo, description, userRestrictions, } = params;
+            const { code, discountType, discountValue, maxUsage, maxUsagePerUser, 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',
+                    errorCode: "INVALID_COUPON_CODE",
+                    message: "Coupon code must be 3-50 uppercase alphanumeric characters",
                 };
             }
             // Validate discount value
@@ -287,8 +316,8 @@ const couponService = ({ strapi }) => ({
             if (!discountValidation.valid) {
                 return {
                     success: false,
-                    errorCode: 'INVALID_DISCOUNT',
-                    message: discountValidation.error || 'Invalid discount value',
+                    errorCode: "INVALID_DISCOUNT",
+                    message: discountValidation.error || "Invalid discount value",
                 };
             }
             // Validate date range
@@ -296,20 +325,21 @@ const couponService = ({ strapi }) => ({
             if (!dateValidation.valid) {
                 return {
                     success: false,
-                    errorCode: 'INVALID_DATE_RANGE',
-                    message: dateValidation.error || 'Invalid date range',
+                    errorCode: "INVALID_DATE_RANGE",
+                    message: dateValidation.error || "Invalid date range",
                 };
             }
             // Validate maxUsage
-            if (maxUsage !== undefined && (typeof maxUsage !== 'number' || maxUsage < 1)) {
+            if (maxUsage !== undefined &&
+                (typeof maxUsage !== "number" || maxUsage < 1)) {
                 return {
                     success: false,
-                    errorCode: 'INVALID_MAX_USAGE',
-                    message: 'maxUsage must be a positive number',
+                    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', {
+            const existingCoupons = await strapi.entityService.findMany("plugin::coupon.coupon", {
                 filters: {
                     code,
                 },
@@ -317,17 +347,18 @@ const couponService = ({ strapi }) => ({
             if (Array.isArray(existingCoupons) && existingCoupons.length > 0) {
                 return {
                     success: false,
-                    errorCode: 'COUPON_ALREADY_EXISTS',
-                    message: 'A coupon with this code already exists.',
+                    errorCode: "COUPON_ALREADY_EXISTS",
+                    message: "A coupon with this code already exists.",
                 };
             }
             // Create the coupon
-            const coupon = await strapi.entityService.create('plugin::coupon.coupon', {
+            const coupon = await strapi.entityService.create("plugin::coupon.coupon", {
                 data: {
                     code,
                     discountType,
                     discountValue,
                     maxUsage: maxUsage || null,
+                    maxUsagePerUser: maxUsagePerUser ?? null,
                     currentUsage: 0,
                     validFrom,
                     validTo,
@@ -339,11 +370,11 @@ const couponService = ({ strapi }) => ({
             return {
                 success: true,
                 couponId: `coupon_${coupon.id}`,
-                message: 'Coupon created successfully.',
+                message: "Coupon created successfully.",
             };
         }
         catch (error) {
-            strapi.log.error('Error creating coupon:', error);
+            strapi.log.error("Error creating coupon:", error);
             throw error;
         }
     },
@@ -352,10 +383,10 @@ const couponService = ({ strapi }) => ({
      */
     async findAll(query = {}) {
         try {
-            return await strapi.entityService.findMany('plugin::coupon.coupon', query);
+            return await strapi.entityService.findMany("plugin::coupon.coupon", query);
         }
         catch (error) {
-            strapi.log.error('Error finding coupons:', error);
+            strapi.log.error("Error finding coupons:", error);
             throw error;
         }
     },
@@ -364,10 +395,10 @@ const couponService = ({ strapi }) => ({
      */
     async findOne(id) {
         try {
-            return await strapi.entityService.findOne('plugin::coupon.coupon', id);
+            return await strapi.entityService.findOne("plugin::coupon.coupon", id);
         }
         catch (error) {
-            strapi.log.error('Error finding coupon:', error);
+            strapi.log.error("Error finding coupon:", error);
             throw error;
         }
     },
@@ -376,10 +407,12 @@ const couponService = ({ strapi }) => ({
      */
     async update(id, data) {
         try {
-            return await strapi.entityService.update('plugin::coupon.coupon', id, { data });
+            return await strapi.entityService.update("plugin::coupon.coupon", id, {
+                data,
+            });
         }
         catch (error) {
-            strapi.log.error('Error updating coupon:', error);
+            strapi.log.error("Error updating coupon:", error);
             throw error;
         }
     },
@@ -388,10 +421,10 @@ const couponService = ({ strapi }) => ({
      */
     async delete(id) {
         try {
-            return await strapi.entityService.delete('plugin::coupon.coupon', id);
+            return await strapi.entityService.delete("plugin::coupon.coupon", id);
         }
         catch (error) {
-            strapi.log.error('Error deleting coupon:', error);
+            strapi.log.error("Error deleting coupon:", error);
             throw error;
         }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mumz-strapi-plugin-coupon",
-  "version": "1.0.7",
+  "version": "1.1.1",
   "description": "Strapi plugin for centralized coupon management across multiple services",
   "strapi": {
     "name": "coupon",