node-paytmpg 7.5.18 → 8.0.2

package/dist/app/controllers/adapters/interfaces.d.ts

@@ -0,0 +1,10 @@
+import { NPConfig, NPPlan, NPSubscription } from "../../models";
+export interface ISubscriptionProvider {
+    createPlan(plan: NPPlan, config: NPConfig): Promise<string>;
+    createSubscription(sub: NPSubscription, plan: NPPlan, config: NPConfig): Promise<{
+        id: string;
+        url: string;
+    }>;
+    getSubscription(gatewayId: string, config: NPConfig): Promise<any>;
+    cancelSubscription(gatewayId: string, cancelAtCycleEnd: boolean, config: NPConfig): Promise<any>;
+}

package/dist/app/controllers/adapters/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/app/controllers/adapters/payu.js

@@ -224,7 +224,7 @@ class PayU {
         }
         let updatedConfig = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, originalOrder);
         this.initParams(updatedConfig);
-        const payuRest = await this.verifyResult(req);
+        const payuRest = await this.verifyResult(req, orderId);
         let result = !!payuRest.STATUS;
         req.body.STATUS = payuRest.STATUS;
         req.body.TXNID = payuRest.TXNID;

package/dist/app/controllers/adapters/razorpay.d.ts

@@ -0,0 +1,15 @@
+import { ISubscriptionProvider } from './interfaces';
+import { NPConfig, NPPlan, NPSubscription } from '../../models';
+/**
+ * Only used for subscriptions for now
+ */
+export declare class RazorpayAdapter implements ISubscriptionProvider {
+    private getInstance;
+    createPlan(plan: NPPlan, config: NPConfig): Promise<string>;
+    createSubscription(sub: NPSubscription, plan: NPPlan, config: NPConfig): Promise<{
+        id: string;
+        url: string;
+    }>;
+    getSubscription(gatewayId: string, config: NPConfig): Promise<any>;
+    cancelSubscription(gatewayId: string, cancelAtCycleEnd: boolean, config: NPConfig): Promise<any>;
+}

package/dist/app/controllers/adapters/razorpay.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RazorpayAdapter = void 0;
+const razorpay_1 = __importDefault(require("razorpay"));
+/**
+ * Only used for subscriptions for now
+ */
+class RazorpayAdapter {
+    getInstance(config) {
+        return new razorpay_1.default({
+            key_id: config.KEY,
+            key_secret: config.SECRET
+        });
+    }
+    async createPlan(plan, config) {
+        const instance = this.getInstance(config);
+        const payload = {
+            period: plan.period,
+            interval: plan.interval,
+            item: {
+                name: plan.name,
+                description: plan.description || plan.name,
+                amount: plan.amount * 100, // Razorpay takes amount in smallest currency unit (paise)
+                currency: plan.currency || 'INR'
+            }
+        };
+        const result = await instance.plans.create(payload);
+        return result.id;
+    }
+    async createSubscription(sub, plan, config) {
+        const instance = this.getInstance(config);
+        const payload = {
+            plan_id: plan.gateway_plan_id,
+            total_count: 120, // A reasonably large default total count to act as 'perpetual' unless overwritten, can be customized later
+            customer_notify: 1 // Let razorpay handle links
+        };
+        // Trial Period Implementation
+        if (plan.trial_days && plan.trial_days > 0) {
+            // start_at should be a unix timestamp (in seconds)
+            const trialEndTimestamp = Math.floor(Date.now() / 1000) + (plan.trial_days * 24 * 60 * 60);
+            payload.start_at = trialEndTimestamp;
+        }
+        const result = await instance.subscriptions.create(payload);
+        return {
+            id: result.id,
+            url: result.short_url
+        };
+    }
+    async getSubscription(gatewayId, config) {
+        const instance = this.getInstance(config);
+        return await instance.subscriptions.fetch(gatewayId);
+    }
+    async cancelSubscription(gatewayId, cancelAtCycleEnd, config) {
+        const instance = this.getInstance(config);
+        return await instance.subscriptions.cancel(gatewayId, cancelAtCycleEnd);
+    }
+}
+exports.RazorpayAdapter = RazorpayAdapter;

package/dist/app/controllers/htmlhelper.d.ts

@@ -6,4 +6,4 @@ export declare function sendAutoPostForm(req: Request, res: Response, action: st
 export declare function buildProcessingPageHtml(innerHtml: string, loadingSVG?: string, title?: string, headScripts?: string, bodyScripts?: string): string;
 export declare function renderProcessingPage(req: Request, res: Response, innerHtml: string, loadingSVG?: string, headScripts?: string, bodyScripts?: string): Response<any, Record<string, any>>;
 export declare function renderPaytmJsCheckout(req: Request, res: Response, paytmJsToken: any, config: NPConfig): Response<any, Record<string, any>>;
-export declare function renderRazorpayCheckout(req: Request, res: Response, params: Record<string, any>, config: NPConfig, loadingSVG: string): Response<any, Record<string, any>>;
+export declare function renderRazorpayCheckout(req: Request, res: Response, params: Record<string, any>, config: NPConfig, loadingSVG: string, isSubscription?: boolean): Response<any, Record<string, any>>;

package/dist/app/controllers/htmlhelper.js

@@ -57,16 +57,14 @@ function renderPaytmJsCheckout(req, res, paytmJsToken, config) {
     const html = (0, paytm_1.createPaytmJsCheckoutHtml)(paytmJsToken, config);
     return res.send(html);
 }
-function renderRazorpayCheckout(req, res, params, config, loadingSVG) {
+function renderRazorpayCheckout(req, res, params, config, loadingSVG, isSubscription = false) {
     var _a, _b;
     const options = {
         key: String(config.KEY),
-        amount: Number(params['TXN_AMOUNT']) * 100,
         currency: 'INR',
         name: params['PRODUCT_NAME'],
-        description: `Order # ${params['ORDER_ID']}`,
+        description: isSubscription ? `Subscription` : `Order # ${params['ORDER_ID']}`,
         image: ((_a = config.theme) === null || _a === void 0 ? void 0 : _a.logo) || '',
-        order_id: params['ORDER_ID'],
         callback_url: params['CALLBACK_URL'],
         prefill: {
             name: params['NAME'],
@@ -77,10 +75,17 @@ function renderRazorpayCheckout(req, res, params, config, loadingSVG) {
             color: ((_b = config.theme) === null || _b === void 0 ? void 0 : _b.accent) || '#086cfe'
         }
     };
+    if (isSubscription) {
+        options.subscription_id = params['ORDER_ID'];
+    }
+    else {
+        options.amount = Number(params['TXN_AMOUNT']) * 100;
+        options.order_id = params['ORDER_ID'];
+    }
     if (wantsJson(req)) {
-        return res.json({ provider: 'razorpay', options, failForm: { action: params['CALLBACK_URL'], fields: { razorpay_order_id: params['ORDER_ID'] } }, loadingSVG });
+        return res.json({ provider: 'razorpay', options, failForm: { action: params['CALLBACK_URL'], fields: isSubscription ? { razorpay_subscription_id: params['ORDER_ID'] } : { razorpay_order_id: params['ORDER_ID'] } }, loadingSVG });
     }
-    const fail = `<div style="display:none"><form method="post" action="${params['CALLBACK_URL']}" id="fail"><input name="razorpay_order_id" value="${params['ORDER_ID']}" hidden="true"/></form></div>`;
+    const fail = `<div style="display:none"><form method="post" action="${params['CALLBACK_URL']}" id="fail"><input name="${isSubscription ? 'razorpay_subscription_id' : 'razorpay_order_id'}" value="${params['ORDER_ID']}" hidden="true"/></form></div>`;
     const scriptOptions = `
         <script src="https://checkout.razorpay.com/v1/checkout.js"></script>
         <script>

package/dist/app/controllers/payment.controller.js

@@ -62,7 +62,7 @@ function makeid(length) {
 }
 class PaymentController {
     constructor(baseConfig, db, callbacks, tableNames) {
-        this.tableNames = { USER: 'npusers', TRANSACTION: 'nptransactions' };
+        this.tableNames = { USER: 'npusers', TRANSACTION: 'nptransactions', PLAN: 'npplans', SUBSCRIPTION: 'npsubscriptions' };
         this.viewPath = '';
         this.baseConfig = baseConfig;
         this.callbacks = callbacks;
@@ -515,12 +515,35 @@ class PaymentController {
         const orderToFind = req.body.ORDERID || req.body.ORDER_ID || req.body.ORDERId || (req.query && req.query.order_id) || req.body.ORDER_ID;
         const myquery = { orderId: orderToFind };
         let objForUpdate = null;
+        let isSubscription = false;
         try {
             objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, myquery).catch(() => null);
             if (!objForUpdate)
                 objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, { id: orderToFind }).catch(() => null);
             if (!objForUpdate)
                 objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, { ORDERID: orderToFind }).catch(() => null);
+            if (!objForUpdate) {
+                const sub = await this.db.getOne(this.tableNames.SUBSCRIPTION, { id: orderToFind }).catch(() => null);
+                if (sub) {
+                    isSubscription = true;
+                    objForUpdate = {
+                        id: sub.id,
+                        orderId: sub.id,
+                        cusId: sub.cusId,
+                        time: sub.createdAt || Date.now(),
+                        status: 'INITIATED',
+                        name: '',
+                        email: '',
+                        phone: '',
+                        amount: 0,
+                        pname: 'Subscription',
+                        extra: '',
+                        clientId: sub.clientId,
+                        returnUrl: sub.returnUrl || '',
+                        webhookUrl: sub.webhookUrl || ''
+                    };
+                }
+            }
         }
         catch {
             objForUpdate = objForUpdate || null;
@@ -586,7 +609,20 @@ class PaymentController {
         objForUpdate.txnId = req.body.TXNID;
         objForUpdate.extra = JSON.stringify(req.body);
         try {
-            await this.db.update(this.tableNames.TRANSACTION, myquery, objForUpdate);
+            if (isSubscription) {
+                await this.db.update(this.tableNames.SUBSCRIPTION, { id: orderToFind }, { status: 'AUTHENTICATED', updatedAt: Date.now() });
+                // Also persist a transaction record so status/history APIs find it
+                const existingTxn = await this.db.getOne(this.tableNames.TRANSACTION, { orderId: orderToFind }).catch(() => null);
+                if (!existingTxn) {
+                    await this.db.insert(this.tableNames.TRANSACTION, objForUpdate);
+                }
+                else {
+                    await this.db.update(this.tableNames.TRANSACTION, { orderId: orderToFind }, objForUpdate);
+                }
+            }
+            else {
+                await this.db.update(this.tableNames.TRANSACTION, myquery, objForUpdate);
+            }
         }
         catch {
             if (returnUrl) {
@@ -655,7 +691,32 @@ class PaymentController {
         }
         let result = false;
         let isCancelled = false;
-        const objForUpdate = await this.getOrder(req);
+        let objForUpdate = await this.getOrder(req);
+        let isSubscriptionCallback = false;
+        // Razorpay Subscription Callback Handling
+        if (!objForUpdate && req.body.razorpay_subscription_id) {
+            const sub = await this.db.getOne(this.tableNames.SUBSCRIPTION, { gateway_subscription_id: req.body.razorpay_subscription_id });
+            if (sub) {
+                isSubscriptionCallback = true;
+                // Create a virtual transaction object for the callback processor
+                objForUpdate = {
+                    id: sub.id,
+                    orderId: sub.id,
+                    cusId: sub.cusId,
+                    time: Date.now(),
+                    status: 'INITIATED',
+                    name: '',
+                    email: '',
+                    phone: '',
+                    amount: 0,
+                    pname: 'Subscription Authentication',
+                    extra: '',
+                    clientId: sub.clientId,
+                    returnUrl: sub.returnUrl || '',
+                    webhookUrl: sub.webhookUrl || ''
+                };
+            }
+        }
         const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, objForUpdate);
         const payuInstance = this.getProviderInstance('PayU', (0, buildConfig_1.withClientConfigOverrides)(config, req, objForUpdate));
         const openMoneyInstance = this.getProviderInstance('OpenMoney', (0, buildConfig_1.withClientConfigOverrides)(config, req, objForUpdate));
@@ -678,28 +739,42 @@ class PaymentController {
             }
         }
         else if (config.razor_url) {
-            let orderid = req.body.razorpay_order_id || req.query.ORDERID || req.query.order_id;
-            let liveResonse = null;
-            if (orderid) {
-                liveResonse = await this.getProviderInstance('Razorpay', config).orders.fetch(orderid).catch(() => null);
-                req.body.extras = liveResonse;
-            }
-            if (req.body.razorpay_payment_id) {
-                result = checksum_1.default.checkRazorSignature(req.body.razorpay_order_id, req.body.razorpay_payment_id, config.SECRET, req.body.razorpay_signature);
+            if (isSubscriptionCallback) {
+                // Subscription verification: Razorpay expects payment_id + "|" + subscription_id
+                result = checksum_1.default.checkRazorSignature(req.body.razorpay_payment_id, req.body.razorpay_subscription_id, config.SECRET, req.body.razorpay_signature);
                 if (result) {
                     req.body.STATUS = 'TXN_SUCCESS';
-                    req.body.ORDERID = req.body.razorpay_order_id;
+                    req.body.ORDERID = objForUpdate === null || objForUpdate === void 0 ? void 0 : objForUpdate.id;
                     req.body.TXNID = req.body.razorpay_payment_id;
+                    // Update local subscription status
+                    await this.db.update(this.tableNames.SUBSCRIPTION, { id: objForUpdate === null || objForUpdate === void 0 ? void 0 : objForUpdate.id }, { status: 'AUTHENTICATED', updatedAt: Date.now() });
                 }
             }
             else {
-                if (req.body.error && req.body.error.metadata && JSON.parse(req.body.error.metadata)) {
-                    const orderId = JSON.parse(req.body.error.metadata).order_id;
-                    req.body.razorpay_order_id = orderId;
+                // Standard Order verification
+                let orderid = req.body.razorpay_order_id || req.query.ORDERID || req.query.order_id;
+                let liveResonse = null;
+                if (orderid) {
+                    liveResonse = await this.getProviderInstance('Razorpay', config).orders.fetch(orderid).catch(() => null);
+                    req.body.extras = liveResonse;
+                }
+                if (req.body.razorpay_payment_id) {
+                    result = checksum_1.default.checkRazorSignature(req.body.razorpay_order_id, req.body.razorpay_payment_id, config.SECRET, req.body.razorpay_signature);
+                    if (result) {
+                        req.body.STATUS = 'TXN_SUCCESS';
+                        req.body.ORDERID = req.body.razorpay_order_id;
+                        req.body.TXNID = req.body.razorpay_payment_id;
+                    }
+                }
+                else {
+                    if (req.body.error && req.body.error.metadata && JSON.parse(req.body.error.metadata)) {
+                        const orderId = JSON.parse(req.body.error.metadata).order_id;
+                        req.body.razorpay_order_id = orderId;
+                    }
+                    req.body.STATUS = (liveResonse === null || liveResonse === void 0 ? void 0 : liveResonse.attempts) ? 'TXN_FAILURE' : 'CANCELLED';
+                    req.body.ORDERID = req.body.razorpay_order_id || req.query.order_id;
+                    isCancelled = true;
                 }
-                req.body.STATUS = (liveResonse === null || liveResonse === void 0 ? void 0 : liveResonse.attempts) ? 'TXN_FAILURE' : 'CANCELLED';
-                req.body.ORDERID = req.body.razorpay_order_id || req.query.order_id;
-                isCancelled = true;
             }
         }
         else if (config.payu_url) {
@@ -750,6 +825,7 @@ class PaymentController {
         return serviceUsed;
     }
     async webhook(req, res) {
+        var _a;
         try {
             let config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
             const payuInstance = this.getProviderInstance('PayU', config);
@@ -763,8 +839,158 @@ class PaymentController {
                 return;
             }
             if (serviceUsed === 'Razorpay') {
-                const events = ["payment.captured", "payment.pending", "payment.failed"];
+                const events = [
+                    "payment.captured", "payment.pending", "payment.failed",
+                    "subscription.authenticated", "subscription.paused", "subscription.resumed",
+                    "subscription.activated", "subscription.pending", "subscription.halted",
+                    "subscription.charged", "subscription.cancelled", "subscription.completed",
+                    "subscription.updated"
+                ];
                 if (req.body.event && events.indexOf(req.body.event) > -1) {
+                    const event = req.body.event;
+                    // Handle Subscription Events
+                    if (event.startsWith("subscription.")) {
+                        if (req.body.payload && req.body.payload.subscription && req.body.payload.subscription.entity) {
+                            const subEntity = req.body.payload.subscription.entity;
+                            const paymentEntity = (_a = req.body.payload.payment) === null || _a === void 0 ? void 0 : _a.entity;
+                            const gateway_subscription_id = subEntity.id;
+                            const reqBody = req.rawBody;
+                            const signature = req.headers["x-razorpay-signature"];
+                            if (signature === undefined) {
+                                res.status(200).send({ message: "Missing Razorpay signature" });
+                                return;
+                            }
+                            let signatureValid;
+                            try {
+                                signatureValid = razorpay_1.default.validateWebhookSignature(reqBody, signature, config.SECRET);
+                            }
+                            catch (e) {
+                                signatureValid = false;
+                            }
+                            if (!signatureValid) {
+                                res.status(200).send({ message: "Invalid Rzpay signature" });
+                                return;
+                            }
+                            // Find the local subscription
+                            const sub = await this.db.getOne(this.tableNames.TRANSACTION.replace('transactions', 'subscriptions'), { gateway_subscription_id });
+                            if (!sub) {
+                                console.log("Subscription not found for webhook:", gateway_subscription_id);
+                                res.status(200).send({ message: "Subscription not found locally" });
+                                return;
+                            }
+                            const clientConf = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, { clientId: sub.clientId });
+                            let statusChanged = false;
+                            // Map Razorpay events to local subscription status
+                            switch (event) {
+                                case "subscription.authenticated":
+                                    sub.status = 'AUTHENTICATED';
+                                    statusChanged = true;
+                                    break;
+                                case "subscription.activated":
+                                case "subscription.resumed":
+                                case "subscription.updated": // An update might make it active again or just change metadata
+                                    if (subEntity.status === 'active') {
+                                        sub.status = 'ACTIVE';
+                                        statusChanged = true;
+                                    }
+                                    break;
+                                case "subscription.paused":
+                                    sub.status = 'PAUSED';
+                                    statusChanged = true;
+                                    break;
+                                case "subscription.pending":
+                                    sub.status = 'PENDING';
+                                    statusChanged = true;
+                                    break;
+                                case "subscription.halted":
+                                    sub.status = 'HALTED';
+                                    statusChanged = true;
+                                    break;
+                                case "subscription.cancelled":
+                                    sub.status = 'CANCELLED';
+                                    statusChanged = true;
+                                    break;
+                                case "subscription.completed":
+                                    sub.status = 'COMPLETED';
+                                    statusChanged = true;
+                                    break;
+                            }
+                            if (statusChanged) {
+                                sub.updatedAt = Date.now();
+                                await this.db.update(this.tableNames.TRANSACTION.replace('transactions', 'subscriptions'), { id: sub.id }, sub);
+                            }
+                            // Trigger client payment webhook ONLY on actual charges or definitive failures
+                            if (event === "subscription.charged" && paymentEntity) {
+                                sub.status = 'ACTIVE';
+                                await this.db.update(this.tableNames.TRANSACTION.replace('transactions', 'subscriptions'), { id: sub.id }, sub);
+                                // Create a new transaction record for this specific charge
+                                const txnId = 'txn_' + makeid(10);
+                                const newTxn = {
+                                    id: txnId,
+                                    orderId: txnId, // Use txnId as orderId for recurring payments since there is no explicit user-created order
+                                    cusId: sub.cusId,
+                                    time: Date.now(),
+                                    status: 'TXN_SUCCESS',
+                                    name: '', // We could fetch from user, but keeping minimal
+                                    email: paymentEntity.email || '',
+                                    phone: paymentEntity.contact || '',
+                                    amount: paymentEntity.amount / 100,
+                                    pname: 'Subscription Charge',
+                                    extra: JSON.stringify(paymentEntity),
+                                    txnId: paymentEntity.id,
+                                    clientId: sub.clientId,
+                                    returnUrl: sub.returnUrl,
+                                    webhookUrl: sub.webhookUrl,
+                                    isSubscription: true,
+                                    subscriptionId: sub.id
+                                };
+                                await this.db.insert(this.tableNames.TRANSACTION, newTxn);
+                                // Trigger client webhook
+                                if (sub.webhookUrl) {
+                                    try {
+                                        await axios_1.default.post(sub.webhookUrl, newTxn);
+                                        console.log("Sent subscription webhook to ", sub.webhookUrl, 'txnId:', paymentEntity.id);
+                                    }
+                                    catch (e) {
+                                        console.log("Error sending subscription webhook to ", sub.webhookUrl, (e === null || e === void 0 ? void 0 : e.message) || e);
+                                    }
+                                }
+                            }
+                            else if (event === "subscription.halted") {
+                                // Optional: Inform client of a failed recurring payment that led to a halt
+                                const txnId = 'txn_' + makeid(10);
+                                const newTxn = {
+                                    id: txnId,
+                                    orderId: txnId,
+                                    cusId: sub.cusId,
+                                    time: Date.now(),
+                                    status: 'TXN_FAILURE',
+                                    name: '',
+                                    email: '',
+                                    phone: '',
+                                    amount: 0, // Or fetch plan amount if needed
+                                    pname: 'Subscription Halted',
+                                    extra: JSON.stringify(subEntity),
+                                    txnId: '',
+                                    clientId: sub.clientId,
+                                    returnUrl: sub.returnUrl,
+                                    webhookUrl: sub.webhookUrl,
+                                    isSubscription: true,
+                                    subscriptionId: sub.id
+                                };
+                                await this.db.insert(this.tableNames.TRANSACTION, newTxn);
+                                if (sub.webhookUrl) {
+                                    try {
+                                        await axios_1.default.post(sub.webhookUrl, newTxn);
+                                    }
+                                    catch (e) { }
+                                }
+                            }
+                            res.status(200).send({ message: "Subscription webhook processed" });
+                            return;
+                        }
+                    }
+                    // Handle One-time Payment Events
                     if (req.body.payload &&
                         req.body.payload.payment &&
                         req.body.payload.payment.entity) {

package/dist/app/controllers/subscription.controller.d.ts

@@ -0,0 +1,22 @@
+import { MultiDbORM } from 'multi-db-orm';
+import { Request, Response } from 'express';
+import { NPConfig, NPTableNames } from '../models';
+export declare class SubscriptionController {
+    private baseConfig;
+    private db;
+    private tableNames;
+    private userController;
+    constructor(baseConfig: NPConfig, db: MultiDbORM, tableNames?: NPTableNames);
+    private configure;
+    private getProvider;
+    createPlan(req: Request, res: Response): Promise<void>;
+    getPlans(req: Request, res: Response): Promise<void>;
+    getPlan(req: Request, res: Response): Promise<void>;
+    updatePlan(req: Request, res: Response): Promise<void>;
+    deletePlan(req: Request, res: Response): Promise<void>;
+    initSubscription(req: Request, res: Response): Promise<void>;
+    checkoutSubscription(req: Request, res: Response): Promise<void>;
+    getSubscription(req: Request, res: Response): Promise<void>;
+    cancelSubscription(req: Request, res: Response): Promise<void>;
+    getSubscriptionPayments(req: Request, res: Response): Promise<void>;
+}

package/dist/app/controllers/subscription.controller.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionController = void 0;
+const buildConfig_1 = require("../utils/buildConfig");
+const razorpay_1 = require("./adapters/razorpay");
+const user_controller_1 = require("./user.controller");
+const utils_1 = require("../utils/utils");
+const htmlhelper_1 = require("./htmlhelper");
+const loadingsvg_1 = require("./static/loadingsvg");
+class SubscriptionController {
+    constructor(baseConfig, db, tableNames) {
+        this.tableNames = { USER: 'npusers', TRANSACTION: 'nptransactions', PLAN: 'npplans', SUBSCRIPTION: 'npsubscriptions' };
+        this.baseConfig = baseConfig;
+        this.db = db;
+        if (tableNames) {
+            this.tableNames = { ...this.tableNames, ...tableNames };
+        }
+        this.userController = new user_controller_1.NPUserController(this.db, this.tableNames.USER);
+        this.configure();
+    }
+    configure() {
+        const planSample = {
+            id: 'plan_sample',
+            name: 'Sample Plan',
+            description: 'Sample Plan',
+            amount: 100,
+            currency: 'INR',
+            period: 'monthly',
+            interval: 1,
+            clientId: 'client_1',
+            gateway_plan_id: 'gw_plan_sample'
+        };
+        const subSample = {
+            id: 'sub_sample',
+            planId: 'plan_sample',
+            cusId: 'user_sample',
+            status: 'CREATED',
+            clientId: 'client_1',
+            gateway_subscription_id: 'gw_sub_sample'
+        };
+        this.db.create(this.tableNames.PLAN, planSample).catch(() => { });
+        this.db.create(this.tableNames.SUBSCRIPTION, subSample).catch(() => { });
+    }
+    getProvider(config) {
+        if (config.razor_url) {
+            return new razorpay_1.RazorpayAdapter();
+        }
+        // Future: add PayU adapter here
+        return null;
+    }
+    // --- PLAN MANAGEMENT ---
+    async createPlan(req, res) {
+        try {
+            const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+            const provider = this.getProvider(config);
+            if (!provider) {
+                res.status(400).send({ message: 'No supported subscription provider configured.' });
+                return;
+            }
+            const { id, name, description, amount, currency, period, interval, trial_days, clientId } = req.body;
+            if (!id || !name || !amount || !period || !interval) {
+                res.status(400).send({ message: 'Missing required fields: id, name, amount, period, interval' });
+                return;
+            }
+            // Check if plan already exists locally
+            const existingPlan = await this.db.getOne(this.tableNames.PLAN, { id });
+            if (existingPlan) {
+                res.status(409).send({ message: 'Plan ID already exists locally.' });
+                return;
+            }
+            const planData = {
+                id, name, description, amount: parseFloat(amount),
+                currency: currency || 'INR', period, interval: parseInt(interval, 10),
+                trial_days: trial_days ? parseInt(trial_days, 10) : 0,
+                clientId: clientId || req.query.client_id || '',
+                createdAt: Date.now(), updatedAt: Date.now(), is_deleted: false
+            };
+            // Register plan with Gateway
+            try {
+                const gatewayPlanId = await provider.createPlan(planData, config);
+                planData.gateway_plan_id = gatewayPlanId;
+            }
+            catch (gwErr) {
+                console.error("Gateway Create Plan Error:", gwErr);
+                res.status(500).send({ message: 'Failed to create plan on Gateway', error: (gwErr === null || gwErr === void 0 ? void 0 : gwErr.message) || gwErr });
+                return;
+            }
+            // Save locally
+            await this.db.insert(this.tableNames.PLAN, planData);
+            res.status(201).send(planData);
+        }
+        catch (err) {
+            console.error("Create Plan Error:", err);
+            res.status(500).send({ message: 'Internal Server Error', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async getPlans(req, res) {
+        try {
+            const clientId = req.query.clientId || req.query.client_id || req.headers['x-client-id'] || '';
+            const query = { is_deleted: false };
+            if (clientId) {
+                query.clientId = clientId;
+            }
+            const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
+            const offset = Math.max(parseInt(req.query.offset, 10) || 0, 0);
+            const plans = await this.db.get(this.tableNames.PLAN, query, {
+                sort: [{ field: 'createdAt', order: 'desc' }],
+                limit: limit, offset: offset
+            });
+            res.send({ limit, offset, count: plans.length, plans });
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error fetching plans', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async getPlan(req, res) {
+        try {
+            const id = req.params.id;
+            const plan = await this.db.getOne(this.tableNames.PLAN, { id, is_deleted: false });
+            if (!plan) {
+                res.status(404).send({ message: 'Plan not found' });
+                return;
+            }
+            res.send(plan);
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error fetching plan', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async updatePlan(req, res) {
+        try {
+            const id = req.params.id;
+            const plan = await this.db.getOne(this.tableNames.PLAN, { id, is_deleted: false });
+            if (!plan) {
+                res.status(404).send({ message: 'Plan not found' });
+                return;
+            }
+            const { name, description, amount, interval, period } = req.body;
+            // Check if Gateway immutable fields are changing
+            let needsNewGatewayPlan = false;
+            if ((amount !== undefined && parseFloat(amount) !== plan.amount) ||
+                (interval !== undefined && parseInt(interval, 10) !== plan.interval) ||
+                (period !== undefined && period !== plan.period)) {
+                needsNewGatewayPlan = true;
+            }
+            const updatedPlan = { ...plan, updatedAt: Date.now() };
+            if (name !== undefined)
+                updatedPlan.name = name;
+            if (description !== undefined)
+                updatedPlan.description = description;
+            if (amount !== undefined)
+                updatedPlan.amount = parseFloat(amount);
+            if (interval !== undefined)
+                updatedPlan.interval = parseInt(interval, 10);
+            if (period !== undefined)
+                updatedPlan.period = period;
+            if (needsNewGatewayPlan) {
+                const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+                const provider = this.getProvider(config);
+                if (provider) {
+                    try {
+                        const newGatewayId = await provider.createPlan(updatedPlan, config);
+                        updatedPlan.gateway_plan_id = newGatewayId;
+                    }
+                    catch (gwErr) {
+                        res.status(500).send({ message: 'Failed to create updated plan on Gateway', error: gwErr === null || gwErr === void 0 ? void 0 : gwErr.message });
+                        return;
+                    }
+                }
+            }
+            await this.db.update(this.tableNames.PLAN, { id }, updatedPlan);
+            res.send(updatedPlan);
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error updating plan', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async deletePlan(req, res) {
+        try {
+            const id = req.params.id;
+            const plan = await this.db.getOne(this.tableNames.PLAN, { id });
+            if (!plan) {
+                res.status(404).send({ message: 'Plan not found' });
+                return;
+            }
+            // Soft delete
+            await this.db.update(this.tableNames.PLAN, { id }, { ...plan, is_deleted: true, updatedAt: Date.now() });
+            res.send({ message: 'Plan deleted successfully', id });
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error deleting plan', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    // --- SUBSCRIPTION MANAGEMENT ---
+    async initSubscription(req, res) {
+        var _a;
+        try {
+            const { planId, returnUrl, webhookUrl, NAME, EMAIL, MOBILE_NO, CLIENT_ID } = req.body;
+            if (!planId || !NAME || !EMAIL) {
+                res.status(400).send({ message: 'Missing required fields: planId, NAME, EMAIL' });
+                return;
+            }
+            const plan = await this.db.getOne(this.tableNames.PLAN, { id: planId, is_deleted: false });
+            if (!plan || !plan.gateway_plan_id) {
+                res.status(404).send({ message: 'Active plan not found or not synced with gateway.' });
+                return;
+            }
+            const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+            const provider = this.getProvider(config);
+            if (!provider) {
+                res.status(400).send({ message: 'No supported subscription provider configured.' });
+                return;
+            }
+            // Create/Get User
+            const user = await this.userController.create({ name: NAME, email: EMAIL, phone: MOBILE_NO });
+            const subId = 'sub_' + utils_1.Utils.makeid(14);
+            const subData = {
+                id: subId,
+                planId: plan.id,
+                cusId: user.id,
+                status: 'CREATED',
+                clientId: CLIENT_ID || req.query.client_id || '',
+                returnUrl: returnUrl || '',
+                webhookUrl: webhookUrl || '',
+                createdAt: Date.now(),
+                updatedAt: Date.now()
+            };
+            // Call Gateway
+            try {
+                const { id: gateway_sub_id, url: short_url } = await provider.createSubscription(subData, plan, config);
+                subData.gateway_subscription_id = gateway_sub_id;
+                subData.short_url = short_url;
+            }
+            catch (gwErr) {
+                console.error("Gateway Sub Error:", gwErr);
+                res.status(500).send({ message: 'Failed to initialize subscription on gateway', error: gwErr === null || gwErr === void 0 ? void 0 : gwErr.message });
+                return;
+            }
+            await this.db.insert(this.tableNames.SUBSCRIPTION, subData);
+            const responseData = {
+                ...subData,
+                orderId: subData.id,
+                payurl: config.host_url + '/' + config.path_prefix + '/sub/checkout/' + subData.id,
+                pname: plan.name,
+                amount: plan.amount,
+                name: user.name,
+                email: user.email,
+                phone: user.phone
+            };
+            if (((_a = req.headers.accept) === null || _a === void 0 ? void 0 : _a.includes('application/json')) || req.path.includes('/createTxn')) {
+                res.status(201).send(responseData);
+            }
+            else if (subData.short_url) {
+                res.redirect(config.host_url + '/' + config.path_prefix + '/sub/checkout/' + subData.id);
+            }
+            else {
+                res.status(201).send(responseData); // fallback
+            }
+        }
+        catch (err) {
+            console.error("Init Sub Error:", err);
+            res.status(500).send({ message: 'Internal server error', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async checkoutSubscription(req, res) {
+        try {
+            const id = req.params.id;
+            const sub = await this.db.getOne(this.tableNames.SUBSCRIPTION, { id });
+            if (!sub || !sub.gateway_subscription_id) {
+                res.status(404).send({ message: 'Subscription not found or not ready.' });
+                return;
+            }
+            const plan = await this.db.getOne(this.tableNames.PLAN, { id: sub.planId });
+            const user = await this.db.getOne(this.tableNames.USER, { id: sub.cusId });
+            const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, { clientId: sub.clientId });
+            const params = {
+                ORDER_ID: sub.gateway_subscription_id,
+                CALLBACK_URL: config.host_url + '/' + config.path_prefix + '/callback',
+                NAME: (user === null || user === void 0 ? void 0 : user.name) || '',
+                EMAIL: (user === null || user === void 0 ? void 0 : user.email) || '',
+                MOBILE_NO: (user === null || user === void 0 ? void 0 : user.phone) || '',
+                PRODUCT_NAME: (plan === null || plan === void 0 ? void 0 : plan.name) || ''
+            };
+            (0, htmlhelper_1.renderRazorpayCheckout)(req, res, params, config, loadingsvg_1.LoadingSVG, true);
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error rendering checkout', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async getSubscription(req, res) {
+        try {
+            const id = req.params.id;
+            const sub = await this.db.getOne(this.tableNames.SUBSCRIPTION, { id });
+            if (!sub) {
+                res.status(404).send({ message: 'Subscription not found' });
+                return;
+            }
+            // Optionally sync from provider
+            if (req.query.sync && sub.gateway_subscription_id) {
+                const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+                const provider = this.getProvider(config);
+                if (provider) {
+                    try {
+                        const gwData = await provider.getSubscription(sub.gateway_subscription_id, config);
+                        let newStatus = sub.status;
+                        if (gwData.status === 'active')
+                            newStatus = 'ACTIVE';
+                        else if (gwData.status === 'authenticated')
+                            newStatus = 'AUTHENTICATED';
+                        else if (gwData.status === 'cancelled')
+                            newStatus = 'CANCELLED';
+                        else if (gwData.status === 'completed')
+                            newStatus = 'COMPLETED';
+                        else if (gwData.status === 'expired')
+                            newStatus = 'EXPIRED';
+                        else if (gwData.status === 'pending' || gwData.status === 'halted')
+                            newStatus = 'HALTED';
+                        if (newStatus !== sub.status) {
+                            sub.status = newStatus;
+                            sub.updatedAt = Date.now();
+                            await this.db.update(this.tableNames.SUBSCRIPTION, { id }, sub);
+                        }
+                    }
+                    catch (gwErr) {
+                        console.error('Failed to sync sub status:', gwErr);
+                    }
+                }
+            }
+            res.send(sub);
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error fetching subscription', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async cancelSubscription(req, res) {
+        try {
+            const id = req.params.id;
+            const cancelAtCycleEnd = req.body.cancel_at_cycle_end === true || req.body.cancel_at_cycle_end === 'true';
+            const sub = await this.db.getOne(this.tableNames.SUBSCRIPTION, { id });
+            if (!sub) {
+                res.status(404).send({ message: 'Subscription not found' });
+                return;
+            }
+            if (sub.status === 'CANCELLED' || sub.status === 'EXPIRED' || sub.status === 'COMPLETED') {
+                res.status(400).send({ message: `Cannot cancel subscription in ${sub.status} state` });
+                return;
+            }
+            const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+            const provider = this.getProvider(config);
+            if (provider && sub.gateway_subscription_id) {
+                try {
+                    await provider.cancelSubscription(sub.gateway_subscription_id, cancelAtCycleEnd, config);
+                    if (!cancelAtCycleEnd) {
+                        sub.status = 'CANCELLED';
+                    }
+                    sub.updatedAt = Date.now();
+                    await this.db.update(this.tableNames.SUBSCRIPTION, { id }, sub);
+                    res.send({ message: 'Cancellation processed successfully', status: sub.status });
+                }
+                catch (gwErr) {
+                    res.status(500).send({ message: 'Failed to cancel on gateway', error: (gwErr === null || gwErr === void 0 ? void 0 : gwErr.message) || gwErr });
+                }
+            }
+            else {
+                res.status(400).send({ message: 'No provider configured or missing gateway subscription ID' });
+            }
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error cancelling subscription', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+    async getSubscriptionPayments(req, res) {
+        try {
+            const id = req.params.id;
+            const sub = await this.db.getOne(this.tableNames.SUBSCRIPTION, { id });
+            if (!sub) {
+                res.status(404).send({ message: 'Subscription not found' });
+                return;
+            }
+            const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
+            const offset = Math.max(parseInt(req.query.offset, 10) || 0, 0);
+            // Fetch transactions linked to this subscription
+            const payments = await this.db.get(this.tableNames.TRANSACTION, { subscriptionId: id }, {
+                sort: [{ field: 'time', order: 'desc' }],
+                limit: limit, offset: offset
+            });
+            res.send({ limit, offset, count: payments.length, payments });
+        }
+        catch (err) {
+            res.status(500).send({ message: 'Error fetching payments', error: err === null || err === void 0 ? void 0 : err.message });
+        }
+    }
+}
+exports.SubscriptionController = SubscriptionController;

package/dist/app/controllers/subscription.webhook.d.ts

@@ -0,0 +1,4 @@
+import { Request, Response } from 'express';
+import { MultiDbORM } from 'multi-db-orm';
+import { NPConfig, NPTableNames } from '../models';
+export declare function handleSubscriptionWebhook(req: Request, res: Response, db: MultiDbORM, baseConfig: NPConfig, tableNames: NPTableNames, makeid: (length: number) => string): Promise<void>;

package/dist/app/controllers/subscription.webhook.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSubscriptionWebhook = handleSubscriptionWebhook;
+const razorpay_1 = __importDefault(require("razorpay"));
+const axios_1 = __importDefault(require("axios"));
+const buildConfig_1 = require("../utils/buildConfig");
+async function handleSubscriptionWebhook(req, res, db, baseConfig, tableNames, makeid) {
+    var _a;
+    const event = req.body.event;
+    const config = (0, buildConfig_1.withClientConfigOverrides)(baseConfig, req);
+    if (req.body.payload && req.body.payload.subscription && req.body.payload.subscription.entity) {
+        const subEntity = req.body.payload.subscription.entity;
+        const paymentEntity = (_a = req.body.payload.payment) === null || _a === void 0 ? void 0 : _a.entity;
+        const gateway_subscription_id = subEntity.id;
+        const reqBody = req.rawBody;
+        const signature = req.headers["x-razorpay-signature"];
+        if (signature === undefined) {
+            res.status(200).send({ message: "Missing Razorpay signature" });
+            return;
+        }
+        let signatureValid;
+        try {
+            signatureValid = razorpay_1.default.validateWebhookSignature(reqBody, signature, config.SECRET);
+        }
+        catch (e) {
+            signatureValid = false;
+        }
+        if (!signatureValid) {
+            res.status(200).send({ message: "Invalid Rzpay signature" });
+            return;
+        }
+        // Find the local subscription
+        const sub = await db.getOne(tableNames.TRANSACTION.replace('transactions', 'subscriptions'), { gateway_subscription_id });
+        if (!sub) {
+            console.log("Subscription not found for webhook:", gateway_subscription_id);
+            res.status(200).send({ message: "Subscription not found locally" });
+            return;
+        }
+        const clientConf = (0, buildConfig_1.withClientConfigOverrides)(baseConfig, req, { clientId: sub.clientId });
+        let statusChanged = false;
+        // Map Razorpay events to local subscription status
+        switch (event) {
+            case "subscription.authenticated":
+                sub.status = 'AUTHENTICATED';
+                statusChanged = true;
+                break;
+            case "subscription.activated":
+            case "subscription.resumed":
+            case "subscription.updated": // An update might make it active again or just change metadata
+                if (subEntity.status === 'active') {
+                    sub.status = 'ACTIVE';
+                    statusChanged = true;
+                }
+                break;
+            case "subscription.paused":
+                sub.status = 'PAUSED';
+                statusChanged = true;
+                break;
+            case "subscription.pending":
+                sub.status = 'PENDING';
+                statusChanged = true;
+                break;
+            case "subscription.halted":
+                sub.status = 'HALTED';
+                statusChanged = true;
+                break;
+            case "subscription.cancelled":
+                sub.status = 'CANCELLED';
+                statusChanged = true;
+                break;
+            case "subscription.completed":
+                sub.status = 'COMPLETED';
+                statusChanged = true;
+                break;
+        }
+        if (statusChanged) {
+            sub.updatedAt = Date.now();
+            await db.update(tableNames.TRANSACTION.replace('transactions', 'subscriptions'), { id: sub.id }, sub);
+        }
+        // Trigger client payment webhook ONLY on actual charges or definitive failures
+        if (event === "subscription.charged" && paymentEntity) {
+            sub.status = 'ACTIVE';
+            await db.update(tableNames.TRANSACTION.replace('transactions', 'subscriptions'), { id: sub.id }, sub);
+            // Create a new transaction record for this specific charge
+            const txnId = 'txn_' + makeid(10);
+            const newTxn = {
+                id: txnId,
+                orderId: txnId, // Use txnId as orderId for recurring payments since there is no explicit user-created order
+                cusId: sub.cusId,
+                time: Date.now(),
+                status: 'TXN_SUCCESS',
+                name: '', // We could fetch from user, but keeping minimal
+                email: paymentEntity.email || '',
+                phone: paymentEntity.contact || '',
+                amount: paymentEntity.amount / 100,
+                pname: 'Subscription Charge',
+                extra: JSON.stringify(paymentEntity),
+                txnId: paymentEntity.id,
+                clientId: sub.clientId,
+                returnUrl: sub.returnUrl,
+                webhookUrl: sub.webhookUrl,
+                isSubscription: true,
+                subscriptionId: sub.id
+            };
+            await db.insert(tableNames.TRANSACTION, newTxn);
+            // Trigger client webhook
+            if (sub.webhookUrl) {
+                try {
+                    await axios_1.default.post(sub.webhookUrl, newTxn);
+                    console.log("Sent subscription webhook to ", sub.webhookUrl, 'txnId:', paymentEntity.id);
+                }
+                catch (e) {
+                    console.log("Error sending subscription webhook to ", sub.webhookUrl, (e === null || e === void 0 ? void 0 : e.message) || e);
+                }
+            }
+        }
+        else if (event === "subscription.halted") {
+            // Optional: Inform client of a failed recurring payment that led to a halt
+            const txnId = 'txn_' + makeid(10);
+            const newTxn = {
+                id: txnId,
+                orderId: txnId,
+                cusId: sub.cusId,
+                time: Date.now(),
+                status: 'TXN_FAILURE',
+                name: '',
+                email: '',
+                phone: '',
+                amount: 0, // Or fetch plan amount if needed
+                pname: 'Subscription Halted',
+                extra: JSON.stringify(subEntity),
+                txnId: '',
+                clientId: sub.clientId,
+                returnUrl: sub.returnUrl,
+                webhookUrl: sub.webhookUrl,
+                isSubscription: true,
+                subscriptionId: sub.id
+            };
+            await db.insert(tableNames.TRANSACTION, newTxn);
+            if (sub.webhookUrl) {
+                try {
+                    await axios_1.default.post(sub.webhookUrl, newTxn);
+                }
+                catch (e) { }
+            }
+        }
+        res.status(200).send({ message: "Subscription webhook processed" });
+        return;
+    }
+}

package/dist/app/models/index.d.ts

@@ -30,6 +30,38 @@ export interface NPTransaction {
     state?: string;
     returnUrl: string;
     webhookUrl: string;
+    isSubscription?: boolean;
+    subscriptionId?: string;
+}
+export interface NPPlan {
+    id: string;
+    name: string;
+    description?: string;
+    amount: number;
+    currency: string;
+    period: 'daily' | 'weekly' | 'monthly' | 'yearly';
+    interval: number;
+    trial_days?: number;
+    gateway_plan_id?: string;
+    clientId: string;
+    is_deleted?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface NPSubscription {
+    id: string;
+    planId: string;
+    cusId: string;
+    status: string;
+    gateway_subscription_id?: string;
+    short_url?: string;
+    clientId: string;
+    returnUrl?: string;
+    webhookUrl?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    expire_by?: number;
+    start_at?: number;
 }
 export interface NPCallbacks {
     onStart: (orderId: string, paymentData?: NPTransaction) => void;
@@ -84,6 +116,8 @@ export type NPConfigOverrides = {
 export type NPTableNames = {
     USER: string;
     TRANSACTION: string;
+    PLAN: string;
+    SUBSCRIPTION: string;
 };
 export type NPParam = {
     ORDER_ID?: string;

package/dist/app/routes/subscription_route.d.ts

@@ -0,0 +1,2 @@
+declare const subscriptionRoute: (app: any, express: any, callbacks?: any) => any;
+export default subscriptionRoute;

package/dist/app/routes/subscription_route.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const subscription_controller_1 = require("../controllers/subscription.controller");
+const subscriptionRoute = function (app, express, callbacks) {
+    const config = app.get('np_config');
+    const sc = new subscription_controller_1.SubscriptionController(config, app);
+    const router = express.Router();
+    // Plan Management
+    router.post('/plans', (req, res) => sc.createPlan(req, res));
+    router.get('/plans', (req, res) => sc.getPlans(req, res));
+    router.get('/plans/:id', (req, res) => sc.getPlan(req, res));
+    router.patch('/plans/:id', (req, res) => sc.updatePlan(req, res));
+    router.delete('/plans/:id', (req, res) => sc.deletePlan(req, res));
+    // Subscription Management
+    router.post('/init', (req, res) => sc.initSubscription(req, res));
+    router.post('/createTxn', (req, res) => sc.initSubscription(req, res));
+    router.post('/createTxn/token', (req, res) => sc.initSubscription(req, res));
+    router.get('/checkout/:id', (req, res) => sc.checkoutSubscription(req, res));
+    router.get('/:id', (req, res) => sc.getSubscription(req, res));
+    router.post('/:id/cancel', (req, res) => sc.cancelSubscription(req, res));
+    router.get('/:id/payments', (req, res) => sc.getSubscriptionPayments(req, res));
+    return router;
+};
+exports.default = subscriptionRoute;

package/dist/index.js

@@ -24,6 +24,7 @@ const path_1 = __importDefault(require("path"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const express_handlebars_1 = __importDefault(require("express-handlebars"));
 const payment_controller_1 = require("./app/controllers/payment.controller");
+const subscription_controller_1 = require("./app/controllers/subscription.controller");
 const buildConfig_1 = require("./app/utils/buildConfig");
 __exportStar(require("./app/models"), exports);
 function attachRawBodyAndEngine(app, userConfig = {}) {
@@ -67,6 +68,7 @@ function createPaymentMiddleware(app, userConfig, db, callbacks, authenticationM
     subApp.use(body_parser_1.default.json({ verify: saveRawBody }));
     callbacks = callbacks || config.callbacks;
     const pc = new payment_controller_1.PaymentController(config, db, callbacks, tableNames);
+    const sc = new subscription_controller_1.SubscriptionController(config, db, tableNames);
     subApp.use((req, res, next) => {
         let _client = (0, buildConfig_1.withClientConfigOverrides)(config, req);
         const theme = _client.theme || {};
@@ -88,6 +90,7 @@ function createPaymentMiddleware(app, userConfig, db, callbacks, authenticationM
         console.log('Received request at', req.originalUrl);
         next();
     });
+    // Payment Routes
     subApp.all('/init', authenticationMiddleware, (req, res) => {
         pc.init(req, res);
     });
@@ -109,6 +112,19 @@ function createPaymentMiddleware(app, userConfig, db, callbacks, authenticationM
     subApp.all('/api/createTxn', authenticationMiddleware, (req, res) => {
         pc.createTxn(req, res);
     });
+    // Subscription Routes
+    subApp.post('/api/plans', authenticationMiddleware, (req, res) => sc.createPlan(req, res));
+    subApp.get('/api/plans', authenticationMiddleware, (req, res) => sc.getPlans(req, res));
+    subApp.get('/api/plans/:id', authenticationMiddleware, (req, res) => sc.getPlan(req, res));
+    subApp.patch('/api/plans/:id', authenticationMiddleware, (req, res) => sc.updatePlan(req, res));
+    subApp.delete('/api/plans/:id', authenticationMiddleware, (req, res) => sc.deletePlan(req, res));
+    subApp.post('/api/sub/init', authenticationMiddleware, (req, res) => sc.initSubscription(req, res));
+    subApp.post('/api/sub/createTxn', authenticationMiddleware, (req, res) => sc.initSubscription(req, res));
+    subApp.post('/api/sub/createTxn/token', authenticationMiddleware, (req, res) => sc.initSubscription(req, res));
+    subApp.all('/sub/checkout/:id', (req, res) => sc.checkoutSubscription(req, res));
+    subApp.get('/api/sub/:id', authenticationMiddleware, (req, res) => sc.getSubscription(req, res));
+    subApp.post('/api/sub/:id/cancel', authenticationMiddleware, (req, res) => sc.cancelSubscription(req, res));
+    subApp.get('/api/sub/:id/payments', authenticationMiddleware, (req, res) => sc.getSubscriptionPayments(req, res));
     subApp.all('/', authenticationMiddleware, (req, res) => {
         pc.init(req, res);
     });

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-paytmpg",
-    "version": "7.5.18",
+    "version": "8.0.2",
     "description": "Payment Gateway Integration using NodeJS",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-paytmpg",
-  "version": "7.5.18",
+  "version": "8.0.2",
   "description": "Payment Gateway Integration using NodeJS",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",