dodopayments-cli 2.0.0

package/dodo-webhooks/functions/generate-refund-data.ts

@@ -0,0 +1,44 @@
+import { type baseArgs } from "../types/baseArgs"
+
+const genBaseRefundData = ({
+    business_id = 'bus_test'
+}: baseArgs) => {
+    return {
+        "business_id": business_id,
+        "data": {
+            "amount": 400,
+            "business_id": business_id,
+            "created_at": new Date().toISOString(),
+            "currency": "USD",
+            "customer": {
+                "customer_id": "cus_test",
+                "email": "test@acme.com",
+                "name": "Test user",
+                "phone_number": null
+            },
+            "is_partial": false,
+            "payload_type": "Refund",
+            "payment_id": "pay_test",
+            "reason": "Testing success refund",
+            "refund_id": "ref_test",
+            "status": "succeeded"
+        },
+        "timestamp": new Date().toISOString(),
+    }
+}
+
+const genRefundSuccess = (args: baseArgs) => {
+    return {
+        ...genBaseRefundData(args),
+        "type": "refund.succeeded"
+    }
+}
+
+const genRefundFailed = (args: baseArgs) => {
+    return {
+        ...genBaseRefundData(args),
+        "type": "refund.failed"
+    }
+}
+
+export { genRefundSuccess, genRefundFailed }

package/dodo-webhooks/functions/generate-subscription-data.ts

@@ -0,0 +1,153 @@
+import { type baseArgs } from '../types/baseArgs';
+
+// For subscription data
+const genBaseSubscriptionData = ({
+    business_id = 'bus_test',
+    product_id = 'pdt_test',
+    subscription_id = 'sub_test',
+    qty = 1,
+    metadata
+}: baseArgs) => {
+    return {
+        "business_id": business_id,
+        "data": {
+            "addons": [],
+            "billing": {
+                "city": "New York",
+                "country": "US",
+                "state": "New York",
+                "street": "11th Main",
+                "zipcode": "12345"
+            },
+            "cancel_at_next_billing_date": false,
+            "cancelled_at": null,
+            "created_at": new Date().toISOString(),
+            "currency": "USD",
+            "customer": {
+                "customer_id": "cus_123456",
+                "email": "test@acme.com",
+                "name": "Test user",
+                "phone_number": null
+            },
+            "discount_cycles_remaining": null,
+            "discount_id": null,
+            "expires_at": null,
+            "metadata": metadata,
+            "meters": [],
+            "next_billing_date": new Date(new Date().setMonth(new Date().getMonth() + 1)),
+            "on_demand": false,
+            "payload_type": "Subscription",
+            "payment_frequency_count": 1,
+            "payment_frequency_interval": "Month",
+            "previous_billing_date": new Date().toISOString(),
+            "product_id": product_id,
+            "quantity": qty,
+            "recurring_pre_tax_amount": 400,
+            "status": "active",
+            "subscription_id": subscription_id,
+            "subscription_period_count": 10,
+            "subscription_period_interval": "Year",
+            "tax_inclusive": false,
+            "trial_period_days": 0
+        },
+        "timestamp": new Date().toISOString()
+    }
+}
+
+const genSubscriptionActive = (args: baseArgs) => {
+    return {
+        ...genBaseSubscriptionData(args),
+        "type": "subscription.active"
+    };
+}
+
+const genSubscriptionUpdated = (args: baseArgs) => {
+    const base = genBaseSubscriptionData(args);
+    return {
+        ...base,
+        "type": "subscription.updated",
+        data: {
+            ...base.data,
+            status: "active"
+        }
+    };
+}
+
+const genSubscriptionOnHold = (args: baseArgs) => {
+    const base = genBaseSubscriptionData(args);
+    return {
+        ...base,
+        "type": "subscription.on_hold",
+        data: {
+            ...base.data,
+            status: "on_hold"
+        }
+    };
+}
+
+const genSubscriptionRenewed = (args: baseArgs) => {
+    return {
+        ...genBaseSubscriptionData(args),
+        "type": "subscription.renewed"
+    };
+}
+
+const genSubscriptionPlanChanged = (args: baseArgs) => {
+    const base = genBaseSubscriptionData(args);
+    return {
+        ...base,
+        "type": "subscription.plan_changed",
+        data: {
+            ...base.data,
+            status: "active"
+        }
+    };
+}
+
+const genSubscriptionCancelled = (args: baseArgs) => {
+    const base = genBaseSubscriptionData(args);
+    return {
+        ...base,
+        "type": "subscription.cancelled",
+        data: {
+            ...base.data,
+            cancel_at_next_billing_date: true,
+            status: 'cancelled'
+        }
+    };
+}
+
+const genSubscriptionFailed = (args: baseArgs) => {
+    const base = genBaseSubscriptionData(args);
+    return {
+        ...base,
+        "type": "subscription.failed",
+        data: {
+            ...base.data,
+            status: "failed"
+        }
+    };
+}
+
+const genSubscriptionExpired = (args: baseArgs) => {
+    const base = genBaseSubscriptionData(args);
+    return {
+        ...base,
+        "type": "subscription.expired",
+        data: {
+            ...base.data,
+            status: "expired"
+        }
+    };
+}
+
+export {
+    genSubscriptionActive,
+    genSubscriptionUpdated,
+    genSubscriptionOnHold,
+    genSubscriptionRenewed,
+    genSubscriptionPlanChanged,
+    genSubscriptionCancelled,
+    genSubscriptionFailed,
+    genSubscriptionExpired
+};

package/dodo-webhooks/functions/supported-events.ts

@@ -0,0 +1,24 @@
+export const supportedEvents: string[] = [
+    "subscription.active",
+    "subscription.updated",
+    "subscription.on_hold",
+    "subscription.renewed",
+    "subscription.plan_changed",
+    "subscription.cancelled",
+    "subscription.failed",
+    "subscription.expired",
+    "payment.success",
+    "payment.failed",
+    "payment.processing",
+    "payment.cancelled",
+    "licence.created",
+    "refund.success",
+    "refund.failed",
+    "dispute.opened",
+    "dispute.expired",
+    "dispute.accepted",
+    "dispute.cancelled",
+    "dispute.challenged",
+    "dispute.won",
+    "dispute.lost"
+];

package/dodo-webhooks/index.ts

@@ -0,0 +1,207 @@
+import { input, password as passwordPrompt, select } from '@inquirer/prompts';
+import { supportedEvents } from './functions/supported-events';
+
+// Subscription Events
+import {
+    genSubscriptionActive,
+    genSubscriptionUpdated,
+    genSubscriptionOnHold,
+    genSubscriptionRenewed,
+    genSubscriptionPlanChanged,
+    genSubscriptionCancelled,
+    genSubscriptionFailed,
+    genSubscriptionExpired
+} from './functions/generate-subscription-data';
+
+// Payment events
+import {
+    genPaymentSuccess,
+    genPaymentFailed,
+    genPaymentProcessing,
+    genPaymentCancelled
+} from './functions/generate-payment-data';
+
+// Refund events
+import {
+    genRefundSuccess,
+    genRefundFailed
+} from './functions/generate-refund-data';
+
+// Dispute events
+import {
+    genDisputeOpened,
+    genDisputeExpired,
+    genDisputeAccepted,
+    genDisputeCancelled,
+    genDisputeChallenged,
+    genDisputeWon,
+    genDisputeLost
+} from './functions/generate-dispute-data';
+
+// Licence events
+import {
+    genLicenceCreated
+} from './functions/generate-licence-data';
+
+const endpoint = await input({
+    message: 'What is your endpoint?',
+    validate: (input) => {
+        if (!input.startsWith('http')) {
+            return 'Please enter a valid URL starting with http or https';
+        }
+        return true;
+    }
+});
+
+// const webhook_secret = await passwordPrompt({
+//     message: 'What is your Dodo Payments webhook secret? (Optional)',
+//     mask: true
+// });
+
+const business_id = await input({
+    message: 'What is your Dodo Payments business ID? (Optional)',
+    default: 'bus_test'
+});
+
+const product_id = await input({
+    message: 'What is your product ID? (Optional)',
+    default: 'pdt_test'
+});
+
+const metadata = await input({
+    message: 'What is your metadata? (JSON stringified, Optional)',
+    default: '{}'
+});
+
+while (true) {
+    const event = await select({
+        message: 'Select an event to send:',
+        choices: [...supportedEvents, 'exit'].map(e => ({ value: e, name: e })),
+        loop: false,
+    });
+
+    if (event === 'exit') {
+        console.log('Exiting...');
+        process.exit();
+    }
+
+    let data;
+    const metadataParsed: { [key: string]: string } = JSON.parse(metadata);
+
+    // Parameters based on subscription event
+    if (event.startsWith('subscription.')) {
+        const params = {
+            business_id,
+            product_id,
+            metadata: metadataParsed
+        };
+
+        if (event === 'subscription.active') {
+            data = genSubscriptionActive(params);
+        } else if (event === 'subscription.updated') {
+            data = genSubscriptionUpdated(params);
+        } else if (event === 'subscription.on_hold') {
+            data = genSubscriptionOnHold(params);
+        } else if (event === 'subscription.renewed') {
+            data = genSubscriptionRenewed(params);
+        } else if (event === 'subscription.plan_changed') {
+            data = genSubscriptionPlanChanged(params);
+        } else if (event === 'subscription.cancelled') {
+            data = genSubscriptionCancelled(params);
+        } else if (event === 'subscription.failed') {
+            data = genSubscriptionFailed(params);
+        } else if (event === 'subscription.expired') {
+            data = genSubscriptionExpired(params);
+        }
+    }
+
+    // Parameters based on payment event
+    if (event.startsWith('payment.')) {
+        const params = {
+            business_id,
+            product_id,
+            metadata: metadataParsed
+        };
+
+        if (event === 'payment.success') {
+            data = genPaymentSuccess(params);
+        } else if (event === 'payment.failed') {
+            data = genPaymentFailed(params);
+        } else if (event === 'payment.processing') {
+            data = genPaymentProcessing(params);
+        } else if (event === 'payment.cancelled') {
+            data = genPaymentCancelled(params);
+        }
+    }
+
+    // Parameters based on refund event
+    if (event.startsWith('refund.')) {
+        const params = {
+            business_id
+        };
+
+        if (event === 'refund.success') {
+            data = genRefundSuccess(params);
+        } else if (event === 'refund.failed') {
+            data = genRefundFailed(params);
+        }
+    }
+
+    // Parameters based on dispute event
+    if (event.startsWith('dispute.')) {
+        const params = {
+            business_id
+        };
+
+        if (event === 'dispute.opened') {
+            data = genDisputeOpened(params);
+        } else if (event === 'dispute.expired') {
+            data = genDisputeExpired(params);
+        } else if (event === 'dispute.accepted') {
+            data = genDisputeAccepted(params);
+        } else if (event === 'dispute.cancelled') {
+            data = genDisputeCancelled(params);
+        } else if (event === 'dispute.challenged') {
+            data = genDisputeChallenged(params);
+        } else if (event === 'dispute.won') {
+            data = genDisputeWon(params);
+        } else if (event === 'dispute.lost') {
+            data = genDisputeLost(params);
+        }
+    }
+
+    // Parameters based on licence event
+    if (event.startsWith('licence.')) {
+        const params = {
+            business_id,
+            product_id
+        };
+
+        if (event === 'licence.created') {
+            data = genLicenceCreated(params);
+        }
+    }
+
+    // const timestamp = new Date();
+    // const webhookId = crypto.randomUUID();
+    // const webhookInstance = new Webhook(webhook_secret);
+    // const payloadString = JSON.stringify(data);
+    // const signature = webhookInstance.sign(webhookId, timestamp, payloadString);
+
+    await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            // "webhook-id": webhookId,
+            // "webhook-timestamp": Math.floor(timestamp.getTime() / 1000).toString(),
+            // "webhook-signature": signature,
+        },
+        body: JSON.stringify(data)
+    }).then(async res => {
+        console.log(`✅ Webhook Event Sent!\nReceived Response Code: ${res.status}\nReceived Response Body: ${await res.text()}`);
+        console.log();
+    }).catch(error => {
+        console.error('❌ Webhook Event Failed:', error);
+        console.log();
+    });
+}

package/dodo-webhooks/types/baseArgs.ts

@@ -0,0 +1,9 @@
+export type baseArgs = {
+    business_id?: string,
+    subscription_id?: string,
+    product_id?: string,
+    qty?: number,
+    metadata?: {
+        [key: string]: string
+    }
+}