mumz-strapi-plugin-coupon 1.1.1 → 3.0.0

package/dist/middlewares/rate-limit.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// Simple in-memory rate limiter
-// Uses in-memory storage - suitable for single-instance deployments
-const rateLimitStore = new Map();
-// Clean up old entries every hour
-setInterval(() => {
-    const now = Date.now();
-    for (const [key, value] of rateLimitStore.entries()) {
-        if (now > value.resetAt) {
-            rateLimitStore.delete(key);
-        }
-    }
-}, 3600000); // 1 hour
-exports.default = (config) => {
-    return async (ctx, next) => {
-        const identifier = ctx.ip || ctx.request.ip || 'unknown';
-        const now = Date.now();
-        const record = rateLimitStore.get(identifier);
-        // No record or expired, create new
-        if (!record || now > record.resetAt) {
-            rateLimitStore.set(identifier, {
-                count: 1,
-                resetAt: now + config.windowMs,
-            });
-            return next();
-        }
-        // Check if limit reached
-        if (record.count >= config.maxRequests) {
-            ctx.status = 429;
-            ctx.body = {
-                error: 'Too many requests',
-                message: `Rate limit exceeded. Please try again in ${Math.ceil((record.resetAt - now) / 1000)} seconds.`,
-                retryAfter: Math.ceil((record.resetAt - now) / 1000),
-            };
-            return;
-        }
-        // Increment counter
-        record.count++;
-        return next();
-    };
-};

package/dist/register.d.ts

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

package/dist/register.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = ({ strapi }) => {
-    // Register plugin custom logic here
-    strapi.log.info('Coupon plugin registered');
-};

package/dist/routes/content-api/index.d.ts

@@ -1,23 +0,0 @@
-declare const _default: {
-    type: string;
-    routes: ({
-        method: string;
-        path: string;
-        handler: string;
-        config: {
-            policies: never[];
-            middlewares: ((ctx: any, next: any) => Promise<any>)[];
-            auth: boolean;
-        };
-    } | {
-        method: string;
-        path: string;
-        handler: string;
-        config: {
-            policies: never[];
-            auth: boolean;
-            middlewares?: undefined;
-        };
-    })[];
-};
-export default _default;

package/dist/routes/content-api/index.js

@@ -1,76 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const rate_limit_1 = __importDefault(require("../../middlewares/rate-limit"));
-exports.default = {
-    type: 'content-api',
-    routes: [
-        {
-            method: 'POST',
-            path: '/validate',
-            handler: 'coupon.validate',
-            config: {
-                policies: [],
-                middlewares: [(0, rate_limit_1.default)({ maxRequests: 10, windowMs: 60000 })], // 10 requests per minute
-                auth: false,
-            },
-        },
-        {
-            method: 'POST',
-            path: '/redeem',
-            handler: 'coupon.redeem',
-            config: {
-                policies: [],
-                middlewares: [(0, rate_limit_1.default)({ maxRequests: 5, windowMs: 60000 })], // 5 requests per minute
-                auth: false,
-            },
-        },
-        {
-            method: 'POST',
-            path: '/',
-            handler: 'coupon.create',
-            config: {
-                policies: [],
-                auth: false,
-            },
-        },
-        {
-            method: 'GET',
-            path: '/',
-            handler: 'coupon.find',
-            config: {
-                policies: [],
-                auth: false,
-            },
-        },
-        {
-            method: 'GET',
-            path: '/:id',
-            handler: 'coupon.findOne',
-            config: {
-                policies: [],
-                auth: false,
-            },
-        },
-        {
-            method: 'PUT',
-            path: '/:id',
-            handler: 'coupon.update',
-            config: {
-                policies: [],
-                auth: false,
-            },
-        },
-        {
-            method: 'DELETE',
-            path: '/:id',
-            handler: 'coupon.delete',
-            config: {
-                policies: [],
-                auth: false,
-            },
-        },
-    ],
-};

package/dist/routes/index.d.ts

@@ -1,25 +0,0 @@
-declare const _default: {
-    'content-api': {
-        type: string;
-        routes: ({
-            method: string;
-            path: string;
-            handler: string;
-            config: {
-                policies: never[];
-                middlewares: ((ctx: any, next: any) => Promise<any>)[];
-                auth: boolean;
-            };
-        } | {
-            method: string;
-            path: string;
-            handler: string;
-            config: {
-                policies: never[];
-                auth: boolean;
-                middlewares?: undefined;
-            };
-        })[];
-    };
-};
-export default _default;

package/dist/routes/index.js

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

package/dist/services/coupon.d.ts

@@ -1,64 +0,0 @@
-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.";
-    readonly COUPON_EXPIRED: "This coupon has expired.";
-    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;
-    phoneNumber: string;
-    orderAmount?: number;
-}
-export interface RedeemCouponRequest {
-    couponCode: string;
-    phoneNumber: string;
-    orderId: string;
-    orderAmount?: number;
-}
-export interface CreateCouponRequest {
-    code: string;
-    discountType: "percentage" | "flat";
-    discountValue: number;
-    maxUsage?: number;
-    maxUsagePerUser?: number;
-    validFrom: string;
-    validTo: string;
-    description?: string;
-    userRestrictions?: string[];
-}
-export interface ValidationResponse {
-    isValid: boolean;
-    errorCode?: string;
-    message: string;
-    discountType?: string;
-    discountValue?: number;
-    discountAmount?: number;
-    finalAmount?: number;
-}
-export interface RedemptionResponse {
-    success: boolean;
-    errorCode?: string;
-    message: string;
-    redemptionId?: string;
-}
-export interface CreateResponse {
-    success: boolean;
-    errorCode?: string;
-    message: string;
-    couponId?: string;
-}
-declare const couponService: ({ strapi }: {
-    strapi: Core.Strapi;
-}) => any;
-export default couponService;

package/dist/services/coupon.js

@@ -1,432 +0,0 @@
-"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",
-    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.",
-    USER_RESTRICTED: "This coupon is not available for your phone number.",
-};
-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 per-user usage limit
-            const existingRedemptions = await strapi.entityService.findMany("plugin::coupon.redemption", {
-                filters: {
-                    coupon: coupon.id,
-                    phoneNumber,
-                },
-            });
-            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,
-                    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 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,
-                },
-            });
-            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,
-                    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, 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",
-                };
-            }
-            // 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,
-                    maxUsagePerUser: maxUsagePerUser ?? 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

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