mumz-strapi-plugin-coupon 1.1.1 → 3.0.0

package/dist/server/index.js

@@ -0,0 +1,1201 @@
+"use strict";
+const register = ({ strapi }) => {
+  strapi.log.info("Coupon plugin registered");
+};
+const bootstrap = ({ strapi }) => {
+  strapi.log.info("Coupon plugin bootstrapped");
+};
+const destroy = ({ strapi }) => {
+  strapi.log.info("Coupon plugin destroyed");
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const schema$1 = {
+  kind: "collectionType",
+  collectionName: "coupons",
+  info: {
+    singularName: "coupon",
+    pluralName: "coupons",
+    displayName: "Coupon",
+    description: "Coupon management for discounts and promotions"
+  },
+  options: {
+    draftAndPublish: false
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: true
+    },
+    "content-type-builder": {
+      visible: true
+    }
+  },
+  layouts: {
+    list: ["code", "discountType", "discountValue", "currentUsage", "maxUsage", "maxUsagePerUser", "isActive", "validFrom", "validTo"],
+    edit: [
+      // -- Coupon Info --
+      [
+        { name: "code", size: 6 },
+        { name: "isActive", size: 6 }
+      ],
+      [
+        { name: "discountType", size: 6 },
+        { name: "discountValue", size: 6 }
+      ],
+      // -- Usage Limits --
+      [
+        { 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 }]
+    ]
+  },
+  attributes: {
+    code: {
+      type: "string",
+      required: true,
+      unique: true,
+      configurable: false
+    },
+    discountType: {
+      type: "enumeration",
+      enum: ["percentage", "flat"],
+      required: true,
+      default: "percentage"
+    },
+    discountValue: {
+      type: "decimal",
+      required: true,
+      min: 0
+    },
+    maxUsage: {
+      type: "integer",
+      required: false,
+      min: 0,
+      default: null
+    },
+    maxUsagePerUser: {
+      type: "integer",
+      required: false,
+      min: 0,
+      default: null
+    },
+    currentUsage: {
+      type: "integer",
+      required: true,
+      default: 0,
+      min: 0
+    },
+    validFrom: {
+      type: "datetime",
+      required: true
+    },
+    validTo: {
+      type: "datetime",
+      required: true
+    },
+    isActive: {
+      type: "boolean",
+      default: true,
+      required: true
+    },
+    description: {
+      type: "text",
+      required: false
+    },
+    userRestrictions: {
+      type: "json",
+      required: false,
+      default: null
+    },
+    redemptions: {
+      type: "relation",
+      relation: "oneToMany",
+      target: "plugin::coupon.redemption",
+      mappedBy: "coupon"
+    }
+  }
+};
+const coupon$1 = {
+  schema: schema$1
+};
+const schema = {
+  kind: "collectionType",
+  collectionName: "coupon_redemptions",
+  info: {
+    singularName: "redemption",
+    pluralName: "redemptions",
+    displayName: "Coupon Redemption",
+    description: "Tracks coupon redemptions for audit trail"
+  },
+  options: {
+    draftAndPublish: false
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: true
+    },
+    "content-type-builder": {
+      visible: true
+    }
+  },
+  layouts: {
+    list: ["orderId", "phoneNumber", "redemptionDate", "coupon"],
+    edit: [
+      [
+        { name: "orderId", size: 6 },
+        { name: "phoneNumber", size: 6 }
+      ],
+      [
+        { name: "redemptionDate", size: 6 },
+        { name: "coupon", size: 6 }
+      ],
+      [
+        { name: "discountType", size: 6 },
+        { name: "discountValue", size: 6 }
+      ],
+      [{ name: "metadata", size: 12 }]
+    ]
+  },
+  attributes: {
+    coupon: {
+      type: "relation",
+      relation: "manyToOne",
+      target: "plugin::coupon.coupon",
+      inversedBy: "redemptions"
+    },
+    orderId: {
+      type: "string",
+      required: true
+    },
+    phoneNumber: {
+      type: "string",
+      required: true
+    },
+    redemptionDate: {
+      type: "datetime",
+      required: true
+    },
+    discountType: {
+      type: "string",
+      required: true
+    },
+    discountValue: {
+      type: "decimal",
+      required: true
+    },
+    metadata: {
+      type: "json",
+      required: false,
+      default: null
+    }
+  }
+};
+const redemption = {
+  schema
+};
+const contentTypes = {
+  coupon: coupon$1,
+  redemption
+};
+const coupon = ({ strapi }) => ({
+  /**
+   * Validate coupon endpoint
+   * POST /api/coupons/validate
+   */
+  async validate(ctx) {
+    try {
+      const { couponCode, phoneNumber, orderAmount } = ctx.request.body;
+      if (!couponCode || !phoneNumber) {
+        return ctx.badRequest("Missing required fields: couponCode, phoneNumber");
+      }
+      const result = await strapi.plugin("coupon").service("coupon").validate({
+        couponCode,
+        phoneNumber,
+        orderAmount
+      });
+      ctx.body = result;
+    } catch (error) {
+      strapi.log.error("Controller error in validate:", error);
+      ctx.internalServerError("An error occurred while validating the coupon");
+    }
+  },
+  /**
+   * Redeem coupon endpoint
+   * POST /api/coupons/redeem
+   */
+  async redeem(ctx) {
+    try {
+      const { couponCode, phoneNumber, orderId, orderAmount } = ctx.request.body;
+      if (!couponCode || !phoneNumber || !orderId) {
+        return ctx.badRequest(
+          "Missing required fields: couponCode, phoneNumber, orderId"
+        );
+      }
+      const result = await strapi.plugin("coupon").service("coupon").redeem({
+        couponCode,
+        phoneNumber,
+        orderId,
+        orderAmount
+      });
+      ctx.body = result;
+    } catch (error) {
+      strapi.log.error("Controller error in redeem:", error);
+      ctx.internalServerError("An error occurred while redeeming the coupon");
+    }
+  },
+  /**
+   * Create coupon endpoint (Admin only)
+   * POST /api/coupons
+   */
+  async create(ctx) {
+    try {
+      const {
+        code,
+        discountType,
+        discountValue,
+        maxUsage,
+        validFrom,
+        validTo,
+        description,
+        userRestrictions
+      } = ctx.request.body;
+      if (!code || !discountType || !discountValue || !validFrom || !validTo) {
+        return ctx.badRequest(
+          "Missing required fields: code, discountType, discountValue, validFrom, validTo"
+        );
+      }
+      const result = await strapi.plugin("coupon").service("coupon").create({
+        code,
+        discountType,
+        discountValue,
+        maxUsage,
+        validFrom,
+        validTo,
+        description,
+        userRestrictions
+      });
+      if (!result.success) {
+        return ctx.badRequest(result.message, { errorCode: result.errorCode });
+      }
+      ctx.body = result;
+    } catch (error) {
+      strapi.log.error("Controller error in create:", error);
+      ctx.internalServerError("An error occurred while creating the coupon");
+    }
+  },
+  /**
+   * Find all coupons
+   * GET /api/coupons
+   */
+  async find(ctx) {
+    try {
+      const coupons = await strapi.plugin("coupon").service("coupon").findAll(ctx.query);
+      ctx.body = coupons;
+    } catch (error) {
+      strapi.log.error("Controller error in find:", error);
+      ctx.internalServerError("An error occurred while fetching coupons");
+    }
+  },
+  /**
+   * Find one coupon
+   * GET /api/coupons/:id
+   */
+  async findOne(ctx) {
+    try {
+      const { id } = ctx.params;
+      const coupon2 = await strapi.plugin("coupon").service("coupon").findOne(id);
+      if (!coupon2) {
+        return ctx.notFound("Coupon not found");
+      }
+      ctx.body = coupon2;
+    } catch (error) {
+      strapi.log.error("Controller error in findOne:", error);
+      ctx.internalServerError("An error occurred while fetching the coupon");
+    }
+  },
+  /**
+   * Update coupon
+   * PUT /api/coupons/:id
+   */
+  async update(ctx) {
+    try {
+      const { id } = ctx.params;
+      const data = ctx.request.body;
+      const coupon2 = await strapi.plugin("coupon").service("coupon").update(id, data);
+      ctx.body = coupon2;
+    } catch (error) {
+      strapi.log.error("Controller error in update:", error);
+      ctx.internalServerError("An error occurred while updating the coupon");
+    }
+  },
+  /**
+   * Delete coupon
+   * DELETE /api/coupons/:id
+   */
+  async delete(ctx) {
+    try {
+      const { id } = ctx.params;
+      const coupon2 = await strapi.plugin("coupon").service("coupon").delete(id);
+      ctx.body = coupon2;
+    } catch (error) {
+      strapi.log.error("Controller error in delete:", error);
+      ctx.internalServerError("An error occurred while deleting the coupon");
+    }
+  },
+  /**
+   * Download CSV template
+   * GET /api/coupons/csv-template
+   */
+  async getCsvTemplate(ctx) {
+    try {
+      const csvContent = strapi.plugin("coupon").service("coupon").generateCsvTemplate();
+      ctx.set("Content-Type", "text/csv");
+      ctx.set("Content-Disposition", 'attachment; filename="coupon-template.csv"');
+      ctx.body = csvContent;
+    } catch (error) {
+      strapi.log.error("Controller error in getCsvTemplate:", error);
+      ctx.internalServerError("An error occurred while generating the CSV template");
+    }
+  },
+  /**
+   * Bulk create coupons from CSV data
+   * POST /api/coupons/bulk-create
+   *
+   * Request body format:
+   * {
+   *   coupons: Array<{
+   *     code: string,
+   *     discountType: 'percentage' | 'flat',
+   *     discountValue: number,
+   *     maxUsage?: number,
+   *     maxUsagePerUser?: number,
+   *     validFrom: string,
+   *     validTo: string,
+   *     description?: string,
+   *     userRestrictions?: string[]
+   *   }>
+   * }
+   */
+  async bulkCreate(ctx) {
+    try {
+      const { coupons } = ctx.request.body;
+      if (!coupons || !Array.isArray(coupons)) {
+        return ctx.badRequest("Missing or invalid coupons array");
+      }
+      if (coupons.length === 0) {
+        return ctx.badRequest("Coupons array is empty");
+      }
+      if (coupons.length > 1e4) {
+        return ctx.badRequest("Maximum 10,000 coupons allowed per bulk import");
+      }
+      const couponService2 = strapi.plugin("coupon").service("coupon");
+      const parsedCoupons = coupons.map((row, index) => {
+        if (row._row !== void 0) {
+          return row;
+        }
+        return couponService2.parseCsvRow(row, index + 1);
+      });
+      const result = await couponService2.bulkCreate(parsedCoupons);
+      ctx.body = result;
+    } catch (error) {
+      strapi.log.error("Controller error in bulkCreate:", error);
+      ctx.internalServerError("An error occurred while bulk creating coupons");
+    }
+  }
+});
+const controllers = {
+  coupon
+};
+const rateLimitStore = /* @__PURE__ */ new Map();
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, value] of rateLimitStore.entries()) {
+    if (now > value.resetAt) {
+      rateLimitStore.delete(key);
+    }
+  }
+}, 36e5);
+const rateLimit = (config2) => {
+  return async (ctx, next) => {
+    const identifier = ctx.ip || ctx.request.ip || "unknown";
+    const now = Date.now();
+    const record = rateLimitStore.get(identifier);
+    if (!record || now > record.resetAt) {
+      rateLimitStore.set(identifier, {
+        count: 1,
+        resetAt: now + config2.windowMs
+      });
+      return next();
+    }
+    if (record.count >= config2.maxRequests) {
+      ctx.status = 429;
+      ctx.body = {
+        error: "Too many requests",
+        message: `Rate limit exceeded. Please try again in ${Math.ceil((record.resetAt - now) / 1e3)} seconds.`,
+        retryAfter: Math.ceil((record.resetAt - now) / 1e3)
+      };
+      return;
+    }
+    record.count++;
+    return next();
+  };
+};
+const contentApi = {
+  type: "content-api",
+  routes: [
+    // Static paths MUST come before dynamic :id routes
+    {
+      method: "GET",
+      path: "/csv-template",
+      handler: "coupon.getCsvTemplate",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/bulk-create",
+      handler: "coupon.bulkCreate",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/validate",
+      handler: "coupon.validate",
+      config: {
+        policies: [],
+        middlewares: [rateLimit({ maxRequests: 10, windowMs: 6e4 })],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/redeem",
+      handler: "coupon.redeem",
+      config: {
+        policies: [],
+        middlewares: [rateLimit({ maxRequests: 5, windowMs: 6e4 })],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/",
+      handler: "coupon.create",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/",
+      handler: "coupon.find",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    // Dynamic :id routes MUST come last
+    {
+      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
+      }
+    }
+  ]
+};
+const routes = {
+  "content-api": contentApi
+};
+const PHONE_REGEX = /^\+?[1-9]\d{1,14}$/;
+const ORDER_ID_REGEX = /^[a-zA-Z0-9_-]{1,100}$/;
+const COUPON_CODE_REGEX = /^[A-Z0-9]{3,50}$/;
+function validatePhoneNumber(phone) {
+  return typeof phone === "string" && phone.length >= 10 && phone.length <= 15 && PHONE_REGEX.test(phone);
+}
+function validateOrderId(orderId) {
+  return typeof orderId === "string" && orderId.length >= 1 && orderId.length <= 100 && ORDER_ID_REGEX.test(orderId);
+}
+function validateCouponCode(code) {
+  return typeof code === "string" && code.length >= 3 && code.length <= 50 && 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 };
+}
+const 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"
+};
+const 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 CSV_COLUMNS = [
+  "code",
+  "discountType",
+  "discountValue",
+  "maxUsage",
+  "maxUsagePerUser",
+  "validFrom",
+  "validTo",
+  "isActive",
+  "description",
+  "userRestrictions"
+];
+const couponService = ({ strapi }) => ({
+  /**
+   * Validate a coupon for a specific service and user
+   */
+  async validate(params) {
+    const { couponCode, phoneNumber, orderAmount = 0 } = params;
+    try {
+      if (!validateCouponCode(couponCode)) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.INVALID_REQUEST,
+          message: "Invalid coupon code format"
+        };
+      }
+      if (!validatePhoneNumber(phoneNumber)) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.INVALID_REQUEST,
+          message: "Invalid phone number format"
+        };
+      }
+      if (orderAmount < 0) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.INVALID_REQUEST,
+          message: "Order amount cannot be negative"
+        };
+      }
+      const coupons = await strapi.entityService.findMany(
+        "plugin::coupon.coupon",
+        {
+          filters: {
+            code: couponCode
+          }
+        }
+      );
+      const coupon2 = Array.isArray(coupons) && coupons.length > 0 ? coupons[0] : null;
+      if (!coupon2) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.COUPON_NOT_FOUND,
+          message: ERROR_MESSAGES.COUPON_NOT_FOUND
+        };
+      }
+      if (!coupon2.isActive) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.COUPON_EXPIRED,
+          message: ERROR_MESSAGES.COUPON_EXPIRED
+        };
+      }
+      const now = /* @__PURE__ */ new Date();
+      const validFrom = new Date(coupon2.validFrom);
+      const validTo = new Date(coupon2.validTo);
+      if (now < validFrom || now > validTo) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.COUPON_EXPIRED,
+          message: ERROR_MESSAGES.COUPON_EXPIRED
+        };
+      }
+      if (coupon2.maxUsage && coupon2.currentUsage >= coupon2.maxUsage) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.USAGE_LIMIT_REACHED,
+          message: ERROR_MESSAGES.USAGE_LIMIT_REACHED
+        };
+      }
+      const existingRedemptions = await strapi.entityService.findMany(
+        "plugin::coupon.redemption",
+        {
+          filters: {
+            coupon: coupon2.id,
+            phoneNumber
+          }
+        }
+      );
+      const userRedemptionCount = Array.isArray(existingRedemptions) ? existingRedemptions.length : 0;
+      const perUserLimit = coupon2.maxUsagePerUser ?? 1;
+      if (perUserLimit === 0 || userRedemptionCount >= perUserLimit) {
+        return {
+          isValid: false,
+          errorCode: ERROR_CODES.COUPON_ALREADY_USED,
+          message: ERROR_MESSAGES.COUPON_ALREADY_USED
+        };
+      }
+      let discountAmount = 0;
+      let finalAmount = orderAmount;
+      if (coupon2.discountType === "percentage") {
+        discountAmount = orderAmount * coupon2.discountValue / 100;
+        finalAmount = orderAmount - discountAmount;
+      } else if (coupon2.discountType === "flat") {
+        discountAmount = coupon2.discountValue;
+        finalAmount = Math.max(0, orderAmount - discountAmount);
+      }
+      return {
+        isValid: true,
+        discountType: coupon2.discountType,
+        discountValue: coupon2.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 {
+      if (!validateOrderId(orderId)) {
+        return {
+          success: false,
+          errorCode: ERROR_CODES.INVALID_REQUEST,
+          message: "Invalid order ID format"
+        };
+      }
+      const coupons = await strapi.db.query("plugin::coupon.coupon").findMany({
+        where: { code: couponCode }
+      });
+      const coupon2 = Array.isArray(coupons) && coupons.length > 0 ? coupons[0] : null;
+      if (!coupon2) {
+        return {
+          success: false,
+          errorCode: ERROR_CODES.COUPON_NOT_FOUND,
+          message: ERROR_MESSAGES.COUPON_NOT_FOUND
+        };
+      }
+      if (!validatePhoneNumber(phoneNumber)) {
+        return {
+          success: false,
+          errorCode: ERROR_CODES.INVALID_REQUEST,
+          message: "Invalid phone number format"
+        };
+      }
+      if (!coupon2.isActive) {
+        return {
+          success: false,
+          errorCode: ERROR_CODES.COUPON_EXPIRED,
+          message: ERROR_MESSAGES.COUPON_EXPIRED
+        };
+      }
+      const now = /* @__PURE__ */ new Date();
+      const validFrom = new Date(coupon2.validFrom);
+      const validTo = new Date(coupon2.validTo);
+      if (now < validFrom || now > validTo) {
+        return {
+          success: false,
+          errorCode: ERROR_CODES.COUPON_EXPIRED,
+          message: ERROR_MESSAGES.COUPON_EXPIRED
+        };
+      }
+      if (coupon2.userRestrictions && Array.isArray(coupon2.userRestrictions)) {
+        if (coupon2.userRestrictions.includes(phoneNumber)) {
+          return {
+            success: false,
+            errorCode: ERROR_CODES.USER_RESTRICTED,
+            message: ERROR_MESSAGES.USER_RESTRICTED
+          };
+        }
+      }
+      const existingRedemptions = await strapi.db.query("plugin::coupon.redemption").findMany({
+        where: {
+          coupon: coupon2.id,
+          phoneNumber
+        }
+      });
+      const userRedemptionCount = Array.isArray(existingRedemptions) ? existingRedemptions.length : 0;
+      const perUserLimit = coupon2.maxUsagePerUser ?? 1;
+      if (perUserLimit === 0 || userRedemptionCount >= perUserLimit) {
+        return {
+          success: false,
+          errorCode: ERROR_CODES.COUPON_ALREADY_USED,
+          message: ERROR_MESSAGES.COUPON_ALREADY_USED
+        };
+      }
+      if (coupon2.maxUsage && coupon2.currentUsage >= coupon2.maxUsage) {
+        return {
+          success: false,
+          errorCode: ERROR_CODES.USAGE_LIMIT_REACHED,
+          message: ERROR_MESSAGES.USAGE_LIMIT_REACHED
+        };
+      }
+      let discountAmount = 0;
+      let finalAmount = orderAmount;
+      if (coupon2.discountType === "percentage") {
+        discountAmount = orderAmount * coupon2.discountValue / 100;
+        finalAmount = orderAmount - discountAmount;
+      } else if (coupon2.discountType === "flat") {
+        discountAmount = coupon2.discountValue;
+        finalAmount = Math.max(0, orderAmount - discountAmount);
+      }
+      let redemptionId;
+      try {
+        const updateResult = await strapi.db.query("plugin::coupon.coupon").update({
+          where: {
+            id: coupon2.id,
+            currentUsage: coupon2.currentUsage
+            // Optimistic lock
+          },
+          data: {
+            currentUsage: coupon2.currentUsage + 1
+          }
+        });
+        if (!updateResult || coupon2.maxUsage && coupon2.currentUsage + 1 > coupon2.maxUsage) {
+          return {
+            success: false,
+            errorCode: ERROR_CODES.USAGE_LIMIT_REACHED,
+            message: ERROR_MESSAGES.USAGE_LIMIT_REACHED
+          };
+        }
+        const redemption2 = await strapi.db.query("plugin::coupon.redemption").create({
+          data: {
+            coupon: coupon2.id,
+            phoneNumber,
+            orderId,
+            discountType: coupon2.discountType,
+            discountValue: coupon2.discountValue,
+            redemptionDate: /* @__PURE__ */ new Date(),
+            metadata: {
+              orderAmount,
+              finalAmount,
+              discountAmount
+            }
+          }
+        });
+        redemptionId = `redeem_${redemption2.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;
+      if (!validateCouponCode(code)) {
+        return {
+          success: false,
+          errorCode: "INVALID_COUPON_CODE",
+          message: "Coupon code must be 3-50 uppercase alphanumeric characters"
+        };
+      }
+      const discountValidation = validateDiscountValue(
+        discountType,
+        discountValue
+      );
+      if (!discountValidation.valid) {
+        return {
+          success: false,
+          errorCode: "INVALID_DISCOUNT",
+          message: discountValidation.error || "Invalid discount value"
+        };
+      }
+      const dateValidation = validateDateRange(validFrom, validTo);
+      if (!dateValidation.valid) {
+        return {
+          success: false,
+          errorCode: "INVALID_DATE_RANGE",
+          message: dateValidation.error || "Invalid date range"
+        };
+      }
+      if (maxUsage !== void 0 && (typeof maxUsage !== "number" || maxUsage < 1)) {
+        return {
+          success: false,
+          errorCode: "INVALID_MAX_USAGE",
+          message: "maxUsage must be a positive number"
+        };
+      }
+      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."
+        };
+      }
+      const coupon2 = 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_${coupon2.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;
+    }
+  },
+  /**
+   * Generate CSV template with headers and example row
+   */
+  generateCsvTemplate() {
+    const headers = CSV_COLUMNS.join(",");
+    const exampleRow = [
+      "SUMMER25",
+      "percentage",
+      "25",
+      "1000",
+      "1",
+      "2025-06-01T00:00:00.000Z",
+      "2025-08-31T23:59:59.000Z",
+      "true",
+      "Summer sale discount",
+      ""
+    ].join(",");
+    const exampleRow2 = [
+      "WELCOME10",
+      "flat",
+      "10",
+      "",
+      "2",
+      "2025-01-01T00:00:00.000Z",
+      "2025-12-31T23:59:59.000Z",
+      "true",
+      "Welcome offer",
+      '"[""971501234567"",""971509876543""]"'
+    ].join(",");
+    return `${headers}
+${exampleRow}
+${exampleRow2}`;
+  },
+  /**
+   * Parse CSV row into CreateCouponRequest
+   */
+  parseCsvRow(row, rowIndex) {
+    const parseNumber = (value) => {
+      if (!value || value.trim() === "") return void 0;
+      const num = parseFloat(value);
+      return isNaN(num) ? void 0 : num;
+    };
+    const parseInteger = (value) => {
+      if (!value || value.trim() === "") return void 0;
+      const num = parseInt(value, 10);
+      return isNaN(num) ? void 0 : num;
+    };
+    const parseUserRestrictions = (value) => {
+      if (!value || value.trim() === "") return void 0;
+      try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+          return parsed.filter((item) => typeof item === "string");
+        }
+        return void 0;
+      } catch {
+        return value.split(",").map((s) => s.trim()).filter(Boolean);
+      }
+    };
+    return {
+      _row: rowIndex,
+      code: (row.code || "").trim().toUpperCase(),
+      discountType: (row.discountType || "percentage").trim().toLowerCase(),
+      discountValue: parseNumber(row.discountValue) || 0,
+      maxUsage: parseInteger(row.maxUsage),
+      maxUsagePerUser: parseInteger(row.maxUsagePerUser),
+      validFrom: (row.validFrom || "").trim(),
+      validTo: (row.validTo || "").trim(),
+      description: row.description?.trim() || void 0,
+      userRestrictions: parseUserRestrictions(row.userRestrictions)
+      // isActive is handled during creation, default to true
+    };
+  },
+  /**
+   * Validate coupons before bulk creation (pre-check for duplicates within batch)
+   */
+  async validateBulkCoupons(coupons) {
+    const valid = [];
+    const invalid = [];
+    const seenCodes = /* @__PURE__ */ new Set();
+    for (const coupon2 of coupons) {
+      if (seenCodes.has(coupon2.code)) {
+        invalid.push({ coupon: coupon2, error: `Duplicate code "${coupon2.code}" within CSV file` });
+      } else {
+        seenCodes.add(coupon2.code);
+        valid.push(coupon2);
+      }
+    }
+    if (valid.length > 0) {
+      const codes = valid.map((c) => c.code);
+      const existingCoupons = await strapi.entityService.findMany(
+        "plugin::coupon.coupon",
+        {
+          filters: {
+            code: { $in: codes }
+          },
+          fields: ["code"]
+        }
+      );
+      const existingCodes = new Set(
+        (Array.isArray(existingCoupons) ? existingCoupons : []).map((c) => c.code)
+      );
+      const stillValid = [];
+      for (const coupon2 of valid) {
+        if (existingCodes.has(coupon2.code)) {
+          invalid.push({ coupon: coupon2, error: `Coupon code "${coupon2.code}" already exists in database` });
+        } else {
+          stillValid.push(coupon2);
+        }
+      }
+      return { valid: stillValid, invalid };
+    }
+    return { valid, invalid };
+  },
+  /**
+   * Bulk create coupons from parsed CSV data
+   * Processes in batches of 100 for performance
+   */
+  async bulkCreate(coupons) {
+    const BATCH_SIZE = 100;
+    const BATCH_DELAY_MS = 50;
+    const results = {
+      success: true,
+      summary: {
+        total: coupons.length,
+        created: 0,
+        failed: 0
+      },
+      created: [],
+      failed: []
+    };
+    if (coupons.length === 0) {
+      return results;
+    }
+    const { valid, invalid } = await this.validateBulkCoupons(coupons);
+    for (const { coupon: coupon2, error } of invalid) {
+      results.failed.push({
+        code: coupon2.code,
+        row: coupon2._row || 0,
+        error,
+        errorCode: "DUPLICATE_CODE"
+      });
+      results.summary.failed++;
+    }
+    for (let i = 0; i < valid.length; i += BATCH_SIZE) {
+      const batch = valid.slice(i, i + BATCH_SIZE);
+      for (const coupon2 of batch) {
+        try {
+          const result = await this.create({
+            code: coupon2.code,
+            discountType: coupon2.discountType,
+            discountValue: coupon2.discountValue,
+            maxUsage: coupon2.maxUsage,
+            maxUsagePerUser: coupon2.maxUsagePerUser,
+            validFrom: coupon2.validFrom,
+            validTo: coupon2.validTo,
+            description: coupon2.description,
+            userRestrictions: coupon2.userRestrictions
+          });
+          if (result.success && result.couponId) {
+            results.created.push({
+              code: coupon2.code,
+              id: result.couponId,
+              row: coupon2._row || 0
+            });
+            results.summary.created++;
+          } else {
+            results.failed.push({
+              code: coupon2.code,
+              row: coupon2._row || 0,
+              error: result.message,
+              errorCode: result.errorCode
+            });
+            results.summary.failed++;
+          }
+        } catch (error) {
+          results.failed.push({
+            code: coupon2.code,
+            row: coupon2._row || 0,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+          results.summary.failed++;
+        }
+      }
+      if (i + BATCH_SIZE < valid.length) {
+        await new Promise((resolve) => setTimeout(resolve, BATCH_DELAY_MS));
+      }
+    }
+    results.success = results.summary.failed === 0;
+    return results;
+  }
+});
+const services = {
+  coupon: couponService
+};
+const plugin = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes
+};
+module.exports = plugin;