@hackthedev/dsync-pay 1.0.0 → 1.0.6

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,8 @@ export default class dSyncPay {
         this.app = app;
         this.domain = domain.endsWith('/') ? domain.slice(0, -1) : domain;
         this.basePath = basePath;
+        this.redirects = redirects;
+        this.metadataCache = new Map();
 
         this.callbacks = {
             onPaymentCreated,
@@ -46,17 +55,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);
             }
@@ -242,6 +252,14 @@ export default class dSyncPay {
                     rawResponse: response
                 };
 
+                // save metadata in cache
+                this.parent.metadataCache.set(response.id, metadata);
+
+                // auto cleanup after 1 hour if never verified
+                setTimeout(() => {
+                    this.parent.metadataCache.delete(response.id);
+                }, 60 * 60 * 1000);
+
                 this.parent.emit('onPaymentCreated', result);
                 return result;
             } catch (error) {
@@ -258,7 +276,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 +285,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 +298,49 @@ export default class dSyncPay {
                             body: {}
                         }
                     );
+
+                    orderStatus = captureResponse.status;
+                    orderResponse = captureResponse;
+                }
+
+                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 purchaseUnit = orderResponse.purchase_units[0];
+                // get metadata from cache
+                const metadata = this.parent.metadataCache.get(orderId) || {};
 
                 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',
+                    metadata,
                     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);
                 }
 
+                // cleanup cache after verify
+                this.parent.metadataCache.delete(orderId);
+
                 return result;
             } catch (error) {
                 this.parent.emit('onError', {
@@ -309,6 +349,10 @@ export default class dSyncPay {
                     orderId,
                     error: error.response || error.message
                 });
+
+                // cleanup cache after verify
+                this.parent.metadataCache.delete(orderId);
+
                 throw error;
             }
         }
@@ -457,6 +501,14 @@ export default class dSyncPay {
                     rawResponse: response
                 };
 
+                // save metadata in cache
+                this.parent.metadataCache.set(response.id, metadata);
+
+                // auto cleanup after 1 hour if never verified
+                setTimeout(() => {
+                    this.parent.metadataCache.delete(response.id);
+                }, 60 * 60 * 1000);
+
                 this.parent.emit('onSubscriptionCreated', result);
                 return result;
             } catch (error) {
@@ -482,6 +534,9 @@ export default class dSyncPay {
                     }
                 );
 
+                // get metadata from cache
+                const metadata = this.parent.metadataCache.get(subscriptionId) || {};
+
                 const result = {
                     provider: 'paypal',
                     type: 'subscription',
@@ -489,15 +544,19 @@ export default class dSyncPay {
                     subscriptionId: response.id,
                     planId: response.plan_id,
                     customId: response.custom_id,
+                    metadata,
                     rawResponse: response
                 };
 
                 if (response.status === 'ACTIVE') {
-                    this.parent.emit('onSubscriptionActivated', result);
+                    await this.parent.emit('onSubscriptionActivated', result);
                 } else if (response.status === 'CANCELLED') {
-                    this.parent.emit('onSubscriptionCancelled', result);
+                    await this.parent.emit('onSubscriptionCancelled', result);
                 }
 
+                // cleanup cache after verify
+                this.parent.metadataCache.delete(subscriptionId);
+
                 return result;
             } catch (error) {
                 this.parent.emit('onError', {
@@ -506,6 +565,10 @@ export default class dSyncPay {
                     subscriptionId,
                     error: error.response || error.message
                 });
+
+                // cleanup cache after verify
+                this.parent.metadataCache.delete(subscriptionId);
+
                 throw error;
             }
         }
@@ -526,15 +589,22 @@ export default class dSyncPay {
                     }
                 );
 
+                // get metadata from cache
+                const metadata = this.parent.metadataCache.get(subscriptionId) || {};
+
                 const result = {
                     provider: 'paypal',
                     type: 'subscription',
                     subscriptionId,
                     status: 'CANCELLED',
-                    reason
+                    reason,
+                    metadata
                 };
 
-                this.parent.emit('onSubscriptionCancelled', result);
+                // cleanup cache
+                this.parent.metadataCache.delete(subscriptionId);
+
+                await this.parent.emit('onSubscriptionCancelled', result);
                 return result;
             } catch (error) {
                 this.parent.emit('onError', {
@@ -543,6 +613,10 @@ export default class dSyncPay {
                     subscriptionId,
                     error: error.response || error.message
                 });
+
+                // cleanup cache on error too
+                this.parent.metadataCache.delete(subscriptionId);
+
                 throw error;
             }
         }
@@ -652,11 +726,11 @@ export default class dSyncPay {
                 };
 
                 if (latestStatus === 'COMPLETED') {
-                    this.parent.emit('onPaymentCompleted', result);
+                    await this.parent.emit('onPaymentCompleted', result);
                 } else if (latestStatus === 'CANCELED') {
-                    this.parent.emit('onPaymentCancelled', result);
+                    await this.parent.emit('onPaymentCancelled', result);
                 } else if (latestStatus === 'EXPIRED' || latestStatus === 'UNRESOLVED') {
-                    this.parent.emit('onPaymentFailed', result);
+                    await this.parent.emit('onPaymentFailed', result);
                 }
 
                 return result;
@@ -679,6 +753,28 @@ export default class dSyncPay {
         }
     }
 
+    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) => {
@@ -687,9 +783,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 +800,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 +829,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 +856,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});
@@ -752,4 +869,4 @@ export default class dSyncPay {
 
         return this;
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackthedev/dsync-pay",
-  "version": "1.0.0",
+  "version": "1.0.6",
   "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": {