mumz-strapi-plugin-coupon 1.0.7

package/dist/index.d.ts

@@ -0,0 +1,201 @@
+import type { Core } from '@strapi/strapi';
+declare const plugin: {
+    register: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => void;
+    destroy: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => void;
+    config: {
+        default: {};
+        validator(): void;
+    };
+    controllers: Record<string, (params: {
+        strapi: Core.Strapi;
+    }) => any>;
+    routes: {
+        '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;
+                };
+            })[];
+        };
+    };
+    services: Record<string, (params: {
+        strapi: Core.Strapi;
+    }) => any>;
+    contentTypes: {
+        coupon: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                layouts: {
+                    list: string[];
+                    edit: {
+                        name: string;
+                        size: number;
+                    }[][];
+                };
+                attributes: {
+                    code: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                        configurable: boolean;
+                    };
+                    discountType: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                        default: string;
+                    };
+                    discountValue: {
+                        type: string;
+                        required: boolean;
+                        min: number;
+                    };
+                    maxUsage: {
+                        type: string;
+                        required: boolean;
+                        min: number;
+                        default: null;
+                    };
+                    currentUsage: {
+                        type: string;
+                        required: boolean;
+                        default: number;
+                        min: number;
+                    };
+                    validFrom: {
+                        type: string;
+                        required: boolean;
+                    };
+                    validTo: {
+                        type: string;
+                        required: boolean;
+                    };
+                    isActive: {
+                        type: string;
+                        default: boolean;
+                        required: boolean;
+                    };
+                    description: {
+                        type: string;
+                        required: boolean;
+                    };
+                    userRestrictions: {
+                        type: string;
+                        required: boolean;
+                        default: null;
+                    };
+                    redemptions: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        mappedBy: string;
+                    };
+                };
+            };
+        };
+        redemption: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                layouts: {
+                    list: string[];
+                    edit: {
+                        name: string;
+                        size: number;
+                    }[][];
+                };
+                attributes: {
+                    coupon: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        inversedBy: string;
+                    };
+                    orderId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    phoneNumber: {
+                        type: string;
+                        required: boolean;
+                    };
+                    redemptionDate: {
+                        type: string;
+                        required: boolean;
+                    };
+                    discountType: {
+                        type: string;
+                        required: boolean;
+                    };
+                    discountValue: {
+                        type: string;
+                        required: boolean;
+                    };
+                    metadata: {
+                        type: string;
+                        required: boolean;
+                        default: null;
+                    };
+                };
+            };
+        };
+    };
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const register_1 = __importDefault(require("./register"));
+const bootstrap_1 = __importDefault(require("./bootstrap"));
+const destroy_1 = __importDefault(require("./destroy"));
+const config_1 = __importDefault(require("./config"));
+const content_types_1 = __importDefault(require("./content-types"));
+const controllers_1 = __importDefault(require("./controllers"));
+const routes_1 = __importDefault(require("./routes"));
+const services_1 = __importDefault(require("./services"));
+const plugin = {
+    register: register_1.default,
+    bootstrap: bootstrap_1.default,
+    destroy: destroy_1.default,
+    config: config_1.default,
+    controllers: controllers_1.default,
+    routes: routes_1.default,
+    services: services_1.default,
+    contentTypes: content_types_1.default,
+};
+exports.default = plugin;

package/dist/middlewares/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    rateLimit: (config: import("./rate-limit").RateLimitConfig) => (ctx: any, next: any) => Promise<any>;
+};
+export default _default;

package/dist/middlewares/index.js

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

package/dist/middlewares/rate-limit.d.ts

@@ -0,0 +1,6 @@
+export interface RateLimitConfig {
+    maxRequests: number;
+    windowMs: number;
+}
+declare const _default: (config: RateLimitConfig) => (ctx: any, next: any) => Promise<any>;
+export default _default;

package/dist/middlewares/rate-limit.js

@@ -0,0 +1,42 @@
+"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

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

package/dist/register.js

@@ -0,0 +1,6 @@
+"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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,76 @@
+"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

@@ -0,0 +1,25 @@
+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

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

package/dist/services/coupon.d.ts

@@ -0,0 +1,61 @@
+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";
+};
+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.";
+};
+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;
+    validFrom: string;
+    validTo: string;
+    description?: string;
+    userRestrictions?: any;
+}
+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;