mumz-strapi-plugin-coupon 1.0.7 → 1.1.0

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.0",
   "description": "Strapi plugin for centralized coupon management across multiple services",
   "strapi": {
     "name": "coupon",