@dodopayments/better-auth 1.0.1 → 1.1.0

package/dist/plugins/checkout.d.ts

@@ -301,4 +301,3 @@ export declare const checkout: (checkoutOptions?: CheckoutOptions) => (dodopayme
         path: "/dodopayments/checkout";
     };
 };
-//# sourceMappingURL=checkout.d.ts.map

package/dist/plugins/checkout.js

@@ -0,0 +1,87 @@
+import { APIError, getSessionFromCtx } from "better-auth/api";
+import { createAuthEndpoint } from "better-auth/plugins";
+import { z } from "zod";
+import { buildCheckoutUrl, dynamicCheckoutBodySchema, } from "@dodopayments/core/checkout";
+export const checkout = (checkoutOptions = {}) => (dodopayments) => {
+    return {
+        checkout: createAuthEndpoint("/dodopayments/checkout", {
+            method: "POST",
+            body: dynamicCheckoutBodySchema.extend({
+                slug: z.string().optional(),
+                referenceId: z.string().optional(),
+            }),
+            requireRequest: true,
+        }, async (ctx) => {
+            const session = await getSessionFromCtx(ctx);
+            let dodoPaymentsProductId;
+            if (ctx.body?.slug) {
+                const resolvedProducts = await (typeof checkoutOptions.products ===
+                    "function"
+                    ? checkoutOptions.products()
+                    : checkoutOptions.products);
+                const productId = resolvedProducts?.find((product) => product.slug === ctx.body.slug)?.productId;
+                if (!productId) {
+                    throw new APIError("BAD_REQUEST", {
+                        message: "Product not found",
+                    });
+                }
+                dodoPaymentsProductId = productId;
+            }
+            else {
+                dodoPaymentsProductId = ctx.body.product_id;
+            }
+            if (checkoutOptions.authenticatedUsersOnly && !session?.user.id) {
+                throw new APIError("UNAUTHORIZED", {
+                    message: "You must be logged in to checkout",
+                });
+            }
+            try {
+                const checkoutUrl = await buildCheckoutUrl({
+                    body: {
+                        ...ctx.body,
+                        customer: {
+                            email: session?.user.email,
+                            name: session?.user.name,
+                            ...ctx.body.customer,
+                        },
+                        product_cart: dodoPaymentsProductId
+                            ? [
+                                {
+                                    product_id: dodoPaymentsProductId,
+                                    quantity: 1,
+                                },
+                            ]
+                            : undefined,
+                        metadata: ctx.body.referenceId
+                            ? {
+                                referenceId: ctx.body.referenceId,
+                                ...ctx.body.metadata,
+                            }
+                            : ctx.body.metadata,
+                    },
+                    bearerToken: dodopayments.bearerToken,
+                    environment: dodopayments.baseURL.includes("test")
+                        ? "test_mode"
+                        : "live_mode",
+                    returnUrl: checkoutOptions.successUrl
+                        ? new URL(checkoutOptions.successUrl, ctx.request?.url).toString()
+                        : undefined,
+                    type: "dynamic",
+                });
+                const redirectUrl = new URL(checkoutUrl);
+                return ctx.json({
+                    url: redirectUrl.toString(),
+                    redirect: true,
+                });
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    ctx.context.logger.error(`DodoPayments checkout creation failed. Error: ${e.message}`);
+                }
+                throw new APIError("INTERNAL_SERVER_ERROR", {
+                    message: "Checkout creation failed",
+                });
+            }
+        }),
+    };
+};

package/dist/plugins/portal.d.ts

@@ -215,4 +215,3 @@ export declare const portal: () => (dodopayments: DodoPayments) => {
         path: "/dodopayments/customer/payments/list";
     };
 };
-//# sourceMappingURL=portal.d.ts.map

package/dist/plugins/portal.js

@@ -0,0 +1,173 @@
+import { APIError } from "better-auth/api";
+import { sessionMiddleware } from "better-auth/api";
+import { createAuthEndpoint } from "better-auth/plugins";
+import { z } from "zod";
+export const portal = () => (dodopayments) => {
+    return {
+        portal: createAuthEndpoint("/dodopayments/customer/portal", {
+            method: "GET",
+            use: [sessionMiddleware],
+        }, async (ctx) => {
+            if (!ctx.context.session?.user.id) {
+                throw new APIError("BAD_REQUEST", {
+                    message: "User not found",
+                });
+            }
+            if (!ctx.context.session?.user.emailVerified) {
+                throw new APIError("UNAUTHORIZED", {
+                    message: "User email not verified",
+                });
+            }
+            try {
+                const customers = await dodopayments.customers.list({
+                    email: ctx.context.session?.user.email,
+                });
+                let customer = customers.items[0];
+                if (!customer) {
+                    // upsert the customer, if they don't exist in DodoPayments
+                    customer = await createCustomer(dodopayments, ctx.context.session.user.email, ctx.context.session.user.name);
+                }
+                const customerSession = await dodopayments.customers.customerPortal.create(customer.customer_id);
+                return ctx.json({
+                    url: customerSession.link,
+                    redirect: true,
+                });
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    ctx.context.logger.error(`DodoPayments customer portal creation failed. Error: ${e.message}`);
+                }
+                throw new APIError("INTERNAL_SERVER_ERROR", {
+                    message: "Customer portal creation failed",
+                });
+            }
+        }),
+        subscriptions: createAuthEndpoint("/dodopayments/customer/subscriptions/list", {
+            method: "GET",
+            query: z
+                .object({
+                page: z.coerce.number().optional(),
+                limit: z.coerce.number().optional(),
+                status: z
+                    .enum([
+                    "active",
+                    "cancelled",
+                    "on_hold",
+                    "pending",
+                    "paused",
+                    "failed",
+                    "expired",
+                ])
+                    .optional(),
+            })
+                .optional(),
+            use: [sessionMiddleware],
+        }, async (ctx) => {
+            if (!ctx.context.session.user.id) {
+                throw new APIError("BAD_REQUEST", {
+                    message: "User not found",
+                });
+            }
+            if (!ctx.context.session?.user.emailVerified) {
+                throw new APIError("UNAUTHORIZED", {
+                    message: "User email not verified",
+                });
+            }
+            try {
+                const customers = await dodopayments.customers.list({
+                    email: ctx.context.session?.user.email,
+                });
+                let customer = customers.items[0];
+                if (!customer) {
+                    // upsert the customer, if they don't exist in DodoPayments
+                    customer = await createCustomer(dodopayments, ctx.context.session.user.email, ctx.context.session.user.name);
+                }
+                const subscriptions = await dodopayments.subscriptions.list({
+                    customer_id: customer.customer_id,
+                    // page number is 0-indexed
+                    page_number: ctx.query?.page ? ctx.query.page - 1 : undefined,
+                    page_size: ctx.query?.limit,
+                    status: ctx.query?.status,
+                });
+                return ctx.json({ items: subscriptions.items });
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    ctx.context.logger.error(`DodoPayments subscriptions list failed. Error: ${e.message}`);
+                }
+                throw new APIError("INTERNAL_SERVER_ERROR", {
+                    message: "DodoPayments subscriptions list failed",
+                });
+            }
+        }),
+        payments: createAuthEndpoint("/dodopayments/customer/payments/list", {
+            method: "GET",
+            query: z
+                .object({
+                page: z.coerce.number().optional(),
+                limit: z.coerce.number().optional(),
+                status: z
+                    .enum([
+                    "succeeded",
+                    "failed",
+                    "cancelled",
+                    "processing",
+                    "requires_customer_action",
+                    "requires_merchant_action",
+                    "requires_payment_method",
+                    "requires_confirmation",
+                    "requires_capture",
+                    "partially_captured",
+                    "partially_captured_and_capturable",
+                ])
+                    .optional(),
+            })
+                .optional(),
+            use: [sessionMiddleware],
+        }, async (ctx) => {
+            if (!ctx.context.session.user.id) {
+                throw new APIError("BAD_REQUEST", {
+                    message: "User not found",
+                });
+            }
+            if (!ctx.context.session?.user.emailVerified) {
+                throw new APIError("UNAUTHORIZED", {
+                    message: "User email not verified",
+                });
+            }
+            try {
+                const customers = await dodopayments.customers.list({
+                    email: ctx.context.session?.user.email,
+                });
+                let customer = customers.items[0];
+                if (!customer) {
+                    // upsert the customer, if they don't exist in DodoPayments
+                    customer = await createCustomer(dodopayments, ctx.context.session.user.email, ctx.context.session.user.name);
+                }
+                const payments = await dodopayments.payments.list({
+                    customer_id: customer.customer_id,
+                    // page number is 0-indexed
+                    page_number: ctx.query?.page ? ctx.query.page - 1 : undefined,
+                    page_size: ctx.query?.limit,
+                    status: ctx.query?.status,
+                });
+                return ctx.json({ items: payments.items });
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    ctx.context.logger.error(`DodoPayments orders list failed. Error: ${e.message}`);
+                }
+                throw new APIError("INTERNAL_SERVER_ERROR", {
+                    message: "Orders list failed",
+                });
+            }
+        }),
+    };
+};
+async function createCustomer(dodopayments, email, name) {
+    const customer = await dodopayments.customers.create({
+        email,
+        name,
+    });
+    return customer;
+}

package/dist/plugins/webhooks.d.ts

@@ -42,4 +42,3 @@ export declare const webhooks: (options: WebhookHandlerConfig) => (_dodopayments
         path: "/dodopayments/webhooks";
     };
 };
-//# sourceMappingURL=webhooks.d.ts.map

package/dist/plugins/webhooks.js

@@ -0,0 +1,62 @@
+import { handleWebhookPayload, } from "@dodopayments/core/webhook";
+import { APIError, createAuthEndpoint } from "better-auth/api";
+import { verifyWebhookPayload } from "@dodopayments/core/webhook";
+export const webhooks = (options) => (_dodopayments) => {
+    return {
+        dodopaymentsWebhooks: createAuthEndpoint("/dodopayments/webhooks", {
+            method: "POST",
+            metadata: {
+                isAction: false,
+            },
+            cloneRequest: true,
+        }, async (ctx) => {
+            const { webhookKey } = options;
+            if (!ctx.request?.body) {
+                throw new APIError("INTERNAL_SERVER_ERROR");
+            }
+            const buf = await ctx.request.text();
+            let event;
+            try {
+                if (!webhookKey) {
+                    throw new APIError("INTERNAL_SERVER_ERROR", {
+                        message: "DodoPayments webhook webhookKey not found",
+                    });
+                }
+                const headers = {
+                    "webhook-id": ctx.request.headers.get("webhook-id"),
+                    "webhook-timestamp": ctx.request.headers.get("webhook-timestamp"),
+                    "webhook-signature": ctx.request.headers.get("webhook-signature"),
+                };
+                event = await verifyWebhookPayload({
+                    webhookKey,
+                    headers,
+                    body: buf,
+                });
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    ctx.context.logger.error(`Webhook Error: ${err.message}`);
+                    throw new APIError("BAD_REQUEST", {
+                        message: `Webhook Error: ${err.message}`,
+                    });
+                }
+                throw new APIError("BAD_REQUEST", {
+                    message: `Webhook Error: ${err}`,
+                });
+            }
+            try {
+                await handleWebhookPayload(event, options);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    ctx.context.logger.error(`DodoPayments webhook failed. Error: ${e.message}`);
+                }
+                ctx.context.logger.error(`DodoPayments webhook failed. Error: ${e}`);
+                throw new APIError("BAD_REQUEST", {
+                    message: "Webhook error: See server logs for more information.",
+                });
+            }
+            return ctx.json({ received: true });
+        }),
+    };
+};

package/dist/types.d.ts

@@ -30,4 +30,3 @@ export interface DodoPaymentsOptions {
      */
     use: DodoPaymentsPlugins;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dodopayments/better-auth",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "rollup -c",
+    "build": "tsc",
     "dev": "rollup -c -w",
     "format": "prettier --write .",
     "check-format": "prettier --check .",
@@ -19,7 +19,10 @@
     }
   },
   "dependencies": {
-    "@dodopayments/core": "*"
+    "@dodopayments/core": "^0.1.14"
+  },
+  "engines": {
+    "node": ">=16.0.0"
   },
   "keywords": [
     "dodopayments",

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,kBAAkB;;wBAGD,UAAU,CAAC,OAAO,YAAY,CAAC;CAE5D,CAAC"}

package/dist/hooks/customer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"customer.d.ts","sourceRoot":"","sources":["../../src/hooks/customer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD,eAAO,MAAM,YAAY,GACtB,SAAS,mBAAmB,MACtB,MAAM,IAAI,EAAE,MAAM,sBAAsB,kBAsC9C,CAAC;AAEJ,eAAO,MAAM,YAAY,GACtB,SAAS,mBAAmB,MACtB,MAAM,IAAI,EAAE,MAAM,sBAAsB,kBA4B9C,CAAC"}