@hackthedev/dsync-pay 1.0.0 → 1.0.5

package/README.md

@@ -4,11 +4,12 @@ As another part of the dSync library family this library is responsible for paym
 
 > [!NOTE]
 >
-> Payment Providers may take a cut from your money or have other fees that are outside of this library's control. 
+> Payment Providers may take a cut from your money or have other fees that are outside of this library's control.
 
 ------
 
 ## Setup
+
 ```js
 import dSyncPay from '@hackthedev/dsync-pay';
 
@@ -17,6 +18,13 @@ const payments = new dSyncPay({
     app,
     domain: 'https://domain.com',
     basePath: '/payments', // optional, default is '/payments'
+    redirects: { // optional, customize redirect pages
+        success: '/payment-success',
+        error: '/payment-error',
+        cancelled: '/payment-cancelled',
+        subscriptionSuccess: '/subscription-success',
+        subscriptionError: '/subscription-error'
+    },
     paypal: {
         clientId: 'xxx',
         clientSecret: 'xxx',
@@ -138,17 +146,33 @@ const result = await payments.coinbase.verifyCharge(chargeCode);
 
 ## Routes
 
-dSyncPay automatically creates verification routes for handling payment returns as well to make the entire payment process as simple and straight forward as possible.
+dSyncPay automatically creates verification routes and redirect pages for handling payment returns to make the entire payment process as simple and straight forward as possible.
+
+### Verification Routes
+
+#### PayPal
+
+- `GET /payments/paypal/verify?token=xxx`
+- `GET /payments/paypal/subscription/verify?subscription_id=xxx`
+- `GET /payments/cancel`
 
-### PayPal
-* `GET /payments/paypal/verify?token=xxx`
-* `GET /payments/paypal/subscription/verify?subscription_id=xxx`
-* `GET /payments/cancel`
+#### Coinbase
 
-### Coinbase
-* `GET /payments/coinbase/verify?code=xxx`
-* `POST /payments/webhook/coinbase` (if webhookSecret set)
-* `GET /payments/cancel`
+- `GET /payments/coinbase/verify?code=xxx`
+- `POST /payments/webhook/coinbase` (if webhookSecret set)
+- `GET /payments/cancel`
+
+### Auto-Generated Redirect Pages
+
+The library automatically creates simple redirect pages at:
+
+- `GET /payment-success` - shown after successful payment
+- `GET /payment-error` - shown when payment fails
+- `GET /payment-cancelled` - shown when user cancels payment
+- `GET /subscription-success` - shown after successful subscription
+- `GET /subscription-error` - shown when subscription fails
+
+You can customize these redirect URLs in the constructor with the `redirects` parameter.
 
 ### Usage Example
 
@@ -161,18 +185,27 @@ const order = await payments.paypal.createOrder({
 // redirect user to order.approvalUrl
 // paypal redirects back to /payments/paypal/verify?token=XXX
 // route automatically verifies and triggers onPaymentCompleted
+// then redirects to /payment-success
 ```
 
-### Custom Base Path
+### Custom Configuration
 
 ```javascript
 const payments = new dSyncPay({
     app,
     domain: 'https://domain.com',
     basePath: '/api/pay', // default is '/payments'
+    redirects: {
+        success: '/custom/success',
+        error: '/custom/error',
+        cancelled: '/custom/cancelled',
+        subscriptionSuccess: '/custom/sub-success',
+        subscriptionError: '/custom/sub-error'
+    },
     paypal: { ... }
 });
 
 // routes: /api/pay/paypal/verify, /api/pay/coinbase/verify, etc.
 // auto urls: https://domain.com/api/pay/paypal/verify
+// redirect pages: /custom/success, /custom/error, etc.
 ```

package/index.mjs

@@ -5,6 +5,13 @@ export default class dSyncPay {
                     app = null,
                     domain = null,
                     basePath = '/payments',
+                    redirects = {
+                        success: '/payment-success',
+                        error: '/payment-error',
+                        cancelled: '/payment-cancelled',
+                        subscriptionSuccess: '/subscription-success',
+                        subscriptionError: '/subscription-error'
+                    },
                     paypal = null,
                     coinbase = null,
                     onPaymentCreated = null,
@@ -22,6 +29,7 @@ export default class dSyncPay {
         this.app = app;
         this.domain = domain.endsWith('/') ? domain.slice(0, -1) : domain;
         this.basePath = basePath;
+        this.redirects = redirects;
 
         this.callbacks = {
             onPaymentCreated,
@@ -46,17 +54,18 @@ export default class dSyncPay {
         }
 
         this.registerRoutes(basePath);
+        this.registerRedirectRoutes();
     }
 
     getUrl(path) {
         return `${this.domain}${this.basePath}${path}`;
     }
 
-    emit(event, data) {
+    async emit(event, data) {
         const callback = this.callbacks[event];
         if (callback) {
             try {
-                callback(data);
+                await callback(data);
             } catch (err) {
                 console.error("callback error:", err);
             }
@@ -258,7 +267,7 @@ export default class dSyncPay {
             const accessToken = await this.getAccessToken();
 
             try {
-                const orderResponse = await this.parent.request(
+                let orderResponse = await this.parent.request(
                     `${this.baseUrl}/v2/checkout/orders/${orderId}`,
                     {
                         headers: {
@@ -267,10 +276,10 @@ export default class dSyncPay {
                     }
                 );
 
-                const orderStatus = orderResponse.status;
+                let orderStatus = orderResponse.status;
 
                 if (orderStatus === "APPROVED") {
-                    await this.parent.request(
+                    const captureResponse = await this.parent.request(
                         `${this.baseUrl}/v2/checkout/orders/${orderId}/capture`,
                         {
                             method: 'POST',
@@ -280,27 +289,41 @@ export default class dSyncPay {
                             body: {}
                         }
                     );
+
+                    orderStatus = captureResponse.status;
+                    orderResponse = captureResponse;
                 }
 
-                const purchaseUnit = orderResponse.purchase_units[0];
+                const purchaseUnit = orderResponse.purchase_units?.[0] || {};
+
+                let amount = 0;
+                let customId = purchaseUnit.custom_id;
+
+                if (purchaseUnit.payments?.captures?.[0]) {
+                    amount = parseFloat(purchaseUnit.payments.captures[0].amount.value);
+                    customId = purchaseUnit.payments.captures[0].custom_id || purchaseUnit.custom_id;
+                } else if (purchaseUnit.amount?.value) {
+                    amount = parseFloat(purchaseUnit.amount.value);
+                }
 
                 const result = {
                     provider: 'paypal',
                     type: 'order',
                     status: orderStatus,
-                    transactionId: purchaseUnit.custom_id,
+                    transactionId: customId,
                     orderId: orderResponse.id,
-                    amount: parseFloat(purchaseUnit.amount.value),
-                    currency: purchaseUnit.amount.currency_code,
+                    amount: amount,
+                    currency: purchaseUnit.payments?.captures?.[0]?.amount?.currency_code || purchaseUnit.amount?.currency_code || 'EUR',
                     rawResponse: orderResponse
                 };
 
                 if (orderStatus === 'COMPLETED') {
-                    this.parent.emit('onPaymentCompleted', result);
-                } else if (orderStatus === 'VOIDED') {
-                    this.parent.emit('onPaymentCancelled', result);
+                    await this.parent.emit('onPaymentCompleted', result);
+                } else if (orderStatus === 'VOIDED' || orderStatus === 'CANCELLED') {
+                    await this.parent.emit('onPaymentCancelled', result);
+                } else {
+                    await this.parent.emit('onPaymentFailed', result);
                 }
-
                 return result;
             } catch (error) {
                 this.parent.emit('onError', {
@@ -679,7 +702,29 @@ export default class dSyncPay {
         }
     }
 
-    registerRoutes(basePath = '/payments') {
+    registerRedirectRoutes() {
+        this.app.get(this.redirects.success, (req, res) => {
+            res.send('payment successful! thank you.');
+        });
+
+        this.app.get(this.redirects.error, (req, res) => {
+            res.send('payment failed. please try again.');
+        });
+
+        this.app.get(this.redirects.cancelled, (req, res) => {
+            res.send('payment cancelled.');
+        });
+
+        this.app.get(this.redirects.subscriptionSuccess, (req, res) => {
+            res.send('subscription activated!');
+        });
+
+        this.app.get(this.redirects.subscriptionError, (req, res) => {
+            res.send('subscription failed.');
+        });
+    }
+
+    registerRoutes(basePath = '/payments') { 
         if (this.paypal) {
             this.app.get(`${basePath}/paypal/verify`, async (req, res) => {
                 try {
@@ -687,9 +732,14 @@ export default class dSyncPay {
                     if (!orderId) return res.status(400).json({ok: false, error: 'missing_token'});
 
                     const result = await this.paypal.verifyOrder(orderId);
-                    res.json({ok: true, ...result});
+
+                    if (result.status === 'COMPLETED') {
+                        return res.redirect(this.redirects.success);
+                    } else {
+                        return res.redirect(this.redirects.error);
+                    }
                 } catch (error) {
-                    res.status(500).json({ok: false, error: error.message});
+                    return res.redirect(this.redirects.error);
                 }
             });
 
@@ -699,14 +749,25 @@ export default class dSyncPay {
                     if (!subscriptionId) return res.status(400).json({ok: false, error: 'missing_subscription_id'});
 
                     const result = await this.paypal.verifySubscription(subscriptionId);
-                    res.json({ok: true, ...result});
+
+                    if (result.status === 'ACTIVE') {
+                        return res.redirect(this.redirects.subscriptionSuccess);
+                    } else {
+                        return res.redirect(this.redirects.subscriptionError);
+                    }
                 } catch (error) {
-                    res.status(500).json({ok: false, error: error.message});
+                    return res.redirect(this.redirects.subscriptionError);
                 }
             });
 
             this.app.get(`${basePath}/cancel`, async (req, res) => {
-                res.send('payment cancelled');
+                const orderId = req.query.token;
+                if (orderId) {
+                    try {
+                        await this.paypal.verifyOrder(orderId);
+                    } catch (e) {}
+                }
+                return res.redirect(this.redirects.cancelled);
             });
         }
 
@@ -717,9 +778,14 @@ export default class dSyncPay {
                     if (!chargeCode) return res.status(400).json({ok: false, error: 'missing_code'});
 
                     const result = await this.coinbase.verifyCharge(chargeCode);
-                    res.json({ok: true, ...result});
+
+                    if (result.status === 'COMPLETED') {
+                        return res.redirect(this.redirects.success);
+                    } else {
+                        return res.redirect(this.redirects.error);
+                    }
                 } catch (error) {
-                    res.status(500).json({ok: false, error: error.message});
+                    return res.redirect(this.redirects.error);
                 }
             });
 
@@ -739,7 +805,7 @@ export default class dSyncPay {
 
                         if (event.event.type === 'charge:confirmed') {
                             const chargeId = event.event.data.id;
-                            const result = await this.coinbase.verifyCharge(chargeId);
+                            await this.coinbase.verifyCharge(chargeId);
                         }
 
                         res.status(200).json({ok: true});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackthedev/dsync-pay",
-  "version": "1.0.0",
+  "version": "1.0.5",
   "description": "As another part of the dSync library family this library is responsible for payment handling currently supporting PayPal and Coinbase Crypto payments. Its works independently and without any percentage cuts by using your own API keys.",
   "homepage": "https://github.com/NETWORK-Z-Dev/dSyncPay#readme",
   "bugs": {