@polar-sh/better-auth 0.1.2 → 1.0.1

package/dist/index.cjs

@@ -20,408 +20,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  polar: () => polar
+  checkout: () => checkout,
+  polar: () => polar,
+  polarClient: () => polarClient,
+  portal: () => portal,
+  usage: () => usage,
+  webhooks: () => webhooks
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/endpoints/checkout.ts
-var import_api = require("better-auth/api");
-var import_plugins = require("better-auth/plugins");
-var import_zod = require("zod");
-var checkout = (options) => (0, import_plugins.createAuthEndpoint)(
-  "/checkout",
-  {
-    method: "GET",
-    query: import_zod.z.object({
-      products: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.string()])
-    })
-  },
-  async (ctx) => {
-    if (!options.checkout?.enabled) {
-      throw new import_api.APIError("BAD_REQUEST", {
-        message: "Checkout is not enabled"
-      });
-    }
-    const products = ctx.query.products;
-    const session = await (0, import_api.getSessionFromCtx)(ctx);
-    if (options.checkout.authenticatedUsersOnly && !session?.user.id) {
-      throw new import_api.APIError("UNAUTHORIZED", {
-        message: "You must be logged in to checkout"
-      });
-    }
-    try {
-      const checkout2 = await options.client.checkouts.create({
-        customerExternalId: session?.user.id,
-        products: Array.isArray(products) ? products : [products],
-        successUrl: options.checkout.successUrl ? new URL(options.checkout.successUrl, ctx.request?.url).toString() : void 0
-      });
-      return ctx.redirect(checkout2.url);
-    } catch (e) {
-      if (e instanceof Error) {
-        ctx.context.logger.error(
-          `Polar checkout creation failed. Error: ${e.message}`
-        );
-      }
-      throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
-        message: "Checkout creation failed"
-      });
-    }
-  }
-);
-var checkoutWithSlug = (options) => (0, import_plugins.createAuthEndpoint)(
-  "/checkout/:slug",
-  {
-    method: "GET",
-    params: import_zod.z.object({
-      slug: import_zod.z.string()
-    })
-  },
-  async (ctx) => {
-    if (!options.checkout?.enabled) {
-      throw new import_api.APIError("BAD_REQUEST", {
-        message: "Checkout is not enabled"
-      });
-    }
-    const products = await (typeof options.checkout.products === "function" ? options.checkout.products() : options.checkout.products);
-    const productId = products.find(
-      (product) => product.slug === ctx.params?.["slug"]
-    )?.productId;
-    if (!productId) {
-      throw new import_api.APIError("BAD_REQUEST", {
-        message: "Product Id not found"
-      });
-    }
-    const session = await (0, import_api.getSessionFromCtx)(ctx);
-    if (options.checkout.authenticatedUsersOnly && !session?.user.id) {
-      throw new import_api.APIError("UNAUTHORIZED", {
-        message: "You must be logged in to checkout"
-      });
-    }
-    try {
-      const checkout2 = await options.client.checkouts.create({
-        customerExternalId: session?.user.id,
-        products: [productId],
-        successUrl: options.checkout.successUrl ? new URL(options.checkout.successUrl, ctx.request?.url).toString() : void 0
-      });
-      return ctx.redirect(checkout2.url);
-    } catch (e) {
-      if (e instanceof Error) {
-        ctx.context.logger.error(
-          `Polar checkout creation failed. Error: ${e.message}`
-        );
-      }
-      throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
-        message: "Checkout creation failed"
-      });
-    }
-  }
-);
-
-// src/endpoints/customerPortal.ts
-var import_api2 = require("better-auth/api");
-var import_plugins2 = require("better-auth/plugins");
-var customerPortal = (options) => (0, import_plugins2.createAuthEndpoint)(
-  "/portal",
-  {
-    method: "GET",
-    use: [import_api2.sessionMiddleware]
-  },
-  async (ctx) => {
-    if (!options.enableCustomerPortal) {
-      throw new import_api2.APIError("BAD_REQUEST", {
-        message: "Customer portal is not enabled"
-      });
-    }
-    if (!ctx.context.session?.user.id) {
-      throw new import_api2.APIError("BAD_REQUEST", {
-        message: "User not found"
-      });
-    }
-    try {
-      const customerSession = await options.client.customerSessions.create({
-        customerExternalId: ctx.context.session?.user.id
-      });
-      return ctx.redirect(customerSession.customerPortalUrl);
-    } catch (e) {
-      if (e instanceof Error) {
-        ctx.context.logger.error(
-          `Polar customer portal creation failed. Error: ${e.message}`
-        );
-      }
-      throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
-        message: "Customer portal creation failed"
-      });
-    }
-  }
-);
-
-// src/endpoints/customerState.ts
-var import_api3 = require("better-auth/api");
-var import_plugins3 = require("better-auth/plugins");
-var customerState = (options) => (0, import_plugins3.createAuthEndpoint)(
-  "/state",
-  {
-    method: "GET",
-    use: [import_api3.sessionMiddleware]
-  },
-  async (ctx) => {
-    if (!ctx.context.session.user.id) {
-      throw new import_api3.APIError("BAD_REQUEST", {
-        message: "User not found"
-      });
-    }
-    try {
-      const state = await options.client.customers.getStateExternal({
-        externalId: ctx.context.session?.user.id
-      });
-      return ctx.json(state);
-    } catch (e) {
-      if (e instanceof Error) {
-        ctx.context.logger.error(
-          `Polar subscriptions list failed. Error: ${e.message}`
-        );
-      }
-      throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
-        message: "Subscriptions list failed"
-      });
-    }
-  }
-);
-
-// src/endpoints/webhooks.ts
-var import_webhooks = require("@polar-sh/sdk/webhooks");
-var import_api4 = require("better-auth/api");
-var import_plugins4 = require("better-auth/plugins");
-var webhooks = (options) => (0, import_plugins4.createAuthEndpoint)(
-  "/polar/webhooks",
-  {
-    method: "POST",
-    metadata: {
-      isAction: false
-    },
-    cloneRequest: true
-  },
-  async (ctx) => {
-    const { webhooks: webhooks2 } = options;
-    if (!webhooks2) {
-      throw new import_api4.APIError("NOT_FOUND", {
-        message: "Webhooks not enabled"
-      });
-    }
-    const {
-      secret,
-      onPayload,
-      onCheckoutCreated,
-      onCheckoutUpdated,
-      onOrderCreated,
-      onOrderPaid,
-      onOrderRefunded,
-      onRefundCreated,
-      onRefundUpdated,
-      onSubscriptionCreated,
-      onSubscriptionUpdated,
-      onSubscriptionActive,
-      onSubscriptionCanceled,
-      onSubscriptionRevoked,
-      onSubscriptionUncanceled,
-      onProductCreated,
-      onProductUpdated,
-      onOrganizationUpdated,
-      onBenefitCreated,
-      onBenefitUpdated,
-      onBenefitGrantCreated,
-      onBenefitGrantUpdated,
-      onBenefitGrantRevoked,
-      onCustomerCreated,
-      onCustomerUpdated,
-      onCustomerDeleted,
-      onCustomerStateChanged
-    } = webhooks2;
-    if (!ctx.request?.body) {
-      throw new import_api4.APIError("INTERNAL_SERVER_ERROR");
-    }
-    const buf = await ctx.request.text();
-    let event;
-    try {
-      if (!secret) {
-        throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
-          message: "Polar webhook secret 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 = (0, import_webhooks.validateEvent)(buf, headers, secret);
-    } catch (err) {
-      if (err instanceof Error) {
-        ctx.context.logger.error(`${err.message}`);
-        throw new import_api4.APIError("BAD_REQUEST", {
-          message: `Webhook Error: ${err.message}`
-        });
-      }
-      throw new import_api4.APIError("BAD_REQUEST", {
-        message: `Webhook Error: ${err}`
-      });
-    }
-    try {
-      if (onPayload) {
-        onPayload(event);
-      }
-      switch (event.type) {
-        case "checkout.created":
-          if (onCheckoutCreated) {
-            onCheckoutCreated(event);
-          }
-          break;
-        case "checkout.updated":
-          if (onCheckoutUpdated) {
-            onCheckoutUpdated(event);
-          }
-          break;
-        case "order.created":
-          if (onOrderCreated) {
-            onOrderCreated(event);
-          }
-          break;
-        case "order.paid":
-          if (onOrderPaid) {
-            onOrderPaid(event);
-          }
-          break;
-        case "subscription.created":
-          if (onSubscriptionCreated) {
-            onSubscriptionCreated(event);
-          }
-          break;
-        case "subscription.updated":
-          if (onSubscriptionUpdated) {
-            onSubscriptionUpdated(event);
-          }
-          break;
-        case "subscription.active":
-          if (onSubscriptionActive) {
-            onSubscriptionActive(event);
-          }
-          break;
-        case "subscription.canceled":
-          if (onSubscriptionCanceled) {
-            onSubscriptionCanceled(event);
-          }
-          break;
-        case "subscription.uncanceled":
-          if (onSubscriptionUncanceled) {
-            onSubscriptionUncanceled(event);
-          }
-          break;
-        case "subscription.revoked":
-          if (onSubscriptionRevoked) {
-            onSubscriptionRevoked(event);
-          }
-          break;
-        case "product.created":
-          if (onProductCreated) {
-            onProductCreated(event);
-          }
-          break;
-        case "product.updated":
-          if (onProductUpdated) {
-            onProductUpdated(event);
-          }
-          break;
-        case "organization.updated":
-          if (onOrganizationUpdated) {
-            onOrganizationUpdated(event);
-          }
-          break;
-        case "benefit.created":
-          if (onBenefitCreated) {
-            onBenefitCreated(event);
-          }
-          break;
-        case "benefit.updated":
-          if (onBenefitUpdated) {
-            onBenefitUpdated(event);
-          }
-          break;
-        case "benefit_grant.created":
-          if (onBenefitGrantCreated) {
-            onBenefitGrantCreated(event);
-          }
-          break;
-        case "benefit_grant.updated":
-          if (onBenefitGrantUpdated) {
-            onBenefitGrantUpdated(event);
-          }
-          break;
-        case "benefit_grant.revoked":
-          if (onBenefitGrantRevoked) {
-            onBenefitGrantRevoked(event);
-          }
-          break;
-        case "order.refunded":
-          if (onOrderRefunded) {
-            onOrderRefunded(event);
-          }
-          break;
-        case "refund.created":
-          if (onRefundCreated) {
-            onRefundCreated(event);
-          }
-          break;
-        case "refund.updated":
-          if (onRefundUpdated) {
-            onRefundUpdated(event);
-          }
-          break;
-        case "customer.created":
-          if (onCustomerCreated) {
-            onCustomerCreated(event);
-          }
-          break;
-        case "customer.updated":
-          if (onCustomerUpdated) {
-            onCustomerUpdated(event);
-          }
-          break;
-        case "customer.deleted":
-          if (onCustomerDeleted) {
-            onCustomerDeleted(event);
-          }
-          break;
-        case "customer.state_changed":
-          if (onCustomerStateChanged) {
-            onCustomerStateChanged(event);
-          }
-          break;
-      }
-    } catch (e) {
-      if (e instanceof Error) {
-        ctx.context.logger.error(`Polar webhook failed. Error: ${e.message}`);
-      } else {
-        ctx.context.logger.error(`Polar webhook failed. Error: ${e}`);
-      }
-      throw new import_api4.APIError("BAD_REQUEST", {
-        message: "Webhook error: See server logs for more information."
-      });
-    }
-    return ctx.json({ received: true });
-  }
-);
-
 // src/hooks/customer.ts
-var import_api5 = require("better-auth/api");
+var import_api = require("better-auth/api");
 var onUserCreate = (options) => async (user, ctx) => {
   if (ctx && options.createCustomerOnSignUp) {
     try {
-      const params = options.getCustomerCreateParams && ctx.context.session ? await options.getCustomerCreateParams({
-        user,
-        session: ctx.context.session.session
+      const params = options.getCustomerCreateParams ? await options.getCustomerCreateParams({
+        user
       }) : {};
       const { result: existingCustomers } = await options.client.customers.list({ email: user.email });
       const existingCustomer = existingCustomers.items[0];
@@ -430,25 +44,27 @@ var onUserCreate = (options) => async (user, ctx) => {
           await options.client.customers.update({
             id: existingCustomer.id,
             customerUpdate: {
-              externalId: user.id
+              externalId: user.id,
+              ...params
             }
           });
         }
       } else {
-        await options.client.customers.create({
+        const customer = await options.client.customers.create({
           ...params,
           email: user.email,
           name: user.name,
           externalId: user.id
         });
+        console.log(customer);
       }
     } catch (e) {
       if (e instanceof Error) {
-        throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+        throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
           message: `Polar customer creation failed. Error: ${e.message}`
         });
       }
-      throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+      throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
         message: `Polar customer creation failed. Error: ${e}`
       });
     }
@@ -459,7 +75,7 @@ var onUserUpdate = (options) => async (user, ctx) => {
     try {
       await options.client.customers.updateExternal({
         externalId: user.id,
-        customerUpdate: {
+        customerUpdateExternalID: {
           email: user.email,
           name: user.name
         }
@@ -476,16 +92,637 @@ var onUserUpdate = (options) => async (user, ctx) => {
   }
 };
 
+// src/client.ts
+var polarClient = () => {
+  return {
+    id: "polar-client",
+    $InferServerPlugin: {}
+  };
+};
+
+// src/plugins/portal.ts
+var import_api2 = require("better-auth/api");
+var import_api3 = require("better-auth/api");
+var import_plugins = require("better-auth/plugins");
+var import_zod = require("zod");
+var portal = () => (polar2) => {
+  return {
+    portal: (0, import_plugins.createAuthEndpoint)(
+      "/customer/portal",
+      {
+        method: "GET",
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        if (!ctx.context.session?.user.id) {
+          throw new import_api2.APIError("BAD_REQUEST", {
+            message: "User not found"
+          });
+        }
+        try {
+          const customerSession = await polar2.customerSessions.create({
+            customerExternalId: ctx.context.session?.user.id
+          });
+          return ctx.json({
+            url: customerSession.customerPortalUrl,
+            redirect: true
+          });
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar customer portal creation failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Customer portal creation failed"
+          });
+        }
+      }
+    ),
+    state: (0, import_plugins.createAuthEndpoint)(
+      "/customer/state",
+      {
+        method: "GET",
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        if (!ctx.context.session.user.id) {
+          throw new import_api2.APIError("BAD_REQUEST", {
+            message: "User not found"
+          });
+        }
+        try {
+          const state = await polar2.customers.getStateExternal({
+            externalId: ctx.context.session?.user.id
+          });
+          return ctx.json(state);
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar subscriptions list failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Subscriptions list failed"
+          });
+        }
+      }
+    ),
+    benefits: (0, import_plugins.createAuthEndpoint)(
+      "/customer/benefits/list",
+      {
+        method: "GET",
+        query: import_zod.z.object({
+          page: import_zod.z.coerce.number().optional(),
+          limit: import_zod.z.coerce.number().optional()
+        }).optional(),
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        if (!ctx.context.session.user.id) {
+          throw new import_api2.APIError("BAD_REQUEST", {
+            message: "User not found"
+          });
+        }
+        try {
+          const customerSession = await polar2.customerSessions.create({
+            customerExternalId: ctx.context.session?.user.id
+          });
+          const benefits = await polar2.customerPortal.benefitGrants.list(
+            { customerSession: customerSession.token },
+            {
+              page: ctx.query?.page,
+              limit: ctx.query?.limit
+            }
+          );
+          return ctx.json(benefits);
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar benefits list failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Benefits list failed"
+          });
+        }
+      }
+    ),
+    subscriptions: (0, import_plugins.createAuthEndpoint)(
+      "/customer/subscriptions/list",
+      {
+        method: "GET",
+        query: import_zod.z.object({
+          referenceId: import_zod.z.string().optional(),
+          page: import_zod.z.coerce.number().optional(),
+          limit: import_zod.z.coerce.number().optional(),
+          active: import_zod.z.coerce.boolean().optional()
+        }).optional(),
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        if (!ctx.context.session.user.id) {
+          throw new import_api2.APIError("BAD_REQUEST", {
+            message: "User not found"
+          });
+        }
+        if (ctx.query?.referenceId) {
+          try {
+            const subscriptions = await polar2.subscriptions.list({
+              page: ctx.query?.page,
+              limit: ctx.query?.limit,
+              active: ctx.query?.active,
+              metadata: {
+                referenceId: ctx.query?.referenceId
+              }
+            });
+            return ctx.json(subscriptions);
+          } catch (e) {
+            console.log(e);
+            if (e instanceof Error) {
+              ctx.context.logger.error(
+                `Polar subscriptions list with referenceId failed. Error: ${e.message}`
+              );
+            }
+            throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+              message: "Subscriptions list with referenceId failed"
+            });
+          }
+        }
+        try {
+          const customerSession = await polar2.customerSessions.create({
+            customerExternalId: ctx.context.session?.user.id
+          });
+          const subscriptions = await polar2.customerPortal.subscriptions.list(
+            { customerSession: customerSession.token },
+            {
+              page: ctx.query?.page,
+              limit: ctx.query?.limit,
+              active: ctx.query?.active
+            }
+          );
+          return ctx.json(subscriptions);
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar subscriptions list failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Polar subscriptions list failed"
+          });
+        }
+      }
+    ),
+    orders: (0, import_plugins.createAuthEndpoint)(
+      "/customer/orders/list",
+      {
+        method: "GET",
+        query: import_zod.z.object({
+          page: import_zod.z.coerce.number().optional(),
+          limit: import_zod.z.coerce.number().optional(),
+          productBillingType: import_zod.z.enum(["recurring", "one_time"]).optional()
+        }).optional(),
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        if (!ctx.context.session.user.id) {
+          throw new import_api2.APIError("BAD_REQUEST", {
+            message: "User not found"
+          });
+        }
+        try {
+          const customerSession = await polar2.customerSessions.create({
+            customerExternalId: ctx.context.session?.user.id
+          });
+          const orders = await polar2.customerPortal.orders.list(
+            { customerSession: customerSession.token },
+            {
+              page: ctx.query?.page,
+              limit: ctx.query?.limit,
+              productBillingType: ctx.query?.productBillingType
+            }
+          );
+          return ctx.json(orders);
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar orders list failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Orders list failed"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/checkout.ts
+var import_api4 = require("better-auth/api");
+var import_plugins2 = require("better-auth/plugins");
+var import_zod2 = require("zod");
+var checkout = (checkoutOptions = {}) => (polar2) => {
+  return {
+    checkout: (0, import_plugins2.createAuthEndpoint)(
+      "/checkout",
+      {
+        method: "POST",
+        body: import_zod2.z.object({
+          products: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.string()]).optional(),
+          slug: import_zod2.z.string().optional(),
+          referenceId: import_zod2.z.string().optional(),
+          customFieldData: import_zod2.z.record(
+            import_zod2.z.string(),
+            import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()])
+          ).optional(),
+          metadata: import_zod2.z.record(
+            import_zod2.z.string(),
+            import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()])
+          ).optional()
+        })
+      },
+      async (ctx) => {
+        const session = await (0, import_api4.getSessionFromCtx)(ctx);
+        let productIds = [];
+        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 import_api4.APIError("BAD_REQUEST", {
+              message: "Product not found"
+            });
+          }
+          productIds = [productId];
+        } else {
+          productIds = Array.isArray(ctx.body.products) ? ctx.body.products.filter((id) => id !== void 0) : [ctx.body.products].filter((id) => id !== void 0);
+        }
+        if (checkoutOptions.authenticatedUsersOnly && !session?.user.id) {
+          throw new import_api4.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to checkout"
+          });
+        }
+        try {
+          const checkout2 = await polar2.checkouts.create({
+            customerExternalId: session?.user.id,
+            products: productIds,
+            successUrl: checkoutOptions.successUrl ? new URL(
+              checkoutOptions.successUrl,
+              ctx.request?.url
+            ).toString() : void 0,
+            metadata: ctx.body.referenceId ? {
+              referenceId: ctx.body.referenceId,
+              ...ctx.body.metadata
+            } : ctx.body.metadata,
+            customFieldData: ctx.body.customFieldData
+          });
+          return ctx.json({
+            url: checkout2.url,
+            redirect: true
+          });
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar checkout creation failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Checkout creation failed"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/usage.ts
+var import_api5 = require("better-auth/api");
+var import_zod3 = require("zod");
+var usage = (_usageOptions) => (polar2) => {
+  return {
+    meters: (0, import_api5.createAuthEndpoint)(
+      "/usage/meters/list",
+      {
+        method: "GET",
+        use: [import_api5.sessionMiddleware],
+        query: import_zod3.z.object({
+          page: import_zod3.z.coerce.number().optional(),
+          limit: import_zod3.z.coerce.number().optional()
+        })
+      },
+      async (ctx) => {
+        if (!ctx.context.session.user.id) {
+          throw new import_api5.APIError("BAD_REQUEST", {
+            message: "User not found"
+          });
+        }
+        try {
+          const customerSession = await polar2.customerSessions.create({
+            customerExternalId: ctx.context.session.user.id
+          });
+          const customerMeters = await polar2.customerPortal.customerMeters.list(
+            { customerSession: customerSession.token },
+            {
+              page: ctx.query?.page,
+              limit: ctx.query?.limit
+            }
+          );
+          return ctx.json(customerMeters);
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar meters list failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Meters list failed"
+          });
+        }
+      }
+    ),
+    ingestion: (0, import_api5.createAuthEndpoint)(
+      "/usage/ingest",
+      {
+        method: "POST",
+        body: import_zod3.z.object({
+          event: import_zod3.z.string(),
+          metadata: import_zod3.z.record(
+            import_zod3.z.string(),
+            import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean()])
+          )
+        }),
+        use: [import_api5.sessionMiddleware]
+      },
+      async (ctx) => {
+        if (!ctx.context.session.user.id) {
+          throw new import_api5.APIError("BAD_REQUEST", {
+            message: "User not found"
+          });
+        }
+        try {
+          const ingestion = await polar2.events.ingest({
+            events: [
+              {
+                name: ctx.body.event,
+                metadata: ctx.body.metadata,
+                externalCustomerId: ctx.context.session.user.id
+              }
+            ]
+          });
+          return ctx.json(ingestion);
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar ingestion failed. Error: ${e.message}`
+            );
+          }
+          throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Ingestion failed"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/webhooks.ts
+var import_webhooks = require("@polar-sh/sdk/webhooks.js");
+var import_api6 = require("better-auth/api");
+var webhooks = (options) => (_polar) => {
+  return {
+    polarWebhooks: (0, import_api6.createAuthEndpoint)(
+      "/polar/webhooks",
+      {
+        method: "POST",
+        metadata: {
+          isAction: false
+        },
+        cloneRequest: true
+      },
+      async (ctx) => {
+        const {
+          secret,
+          onPayload,
+          onCheckoutCreated,
+          onCheckoutUpdated,
+          onOrderCreated,
+          onOrderPaid,
+          onOrderRefunded,
+          onRefundCreated,
+          onRefundUpdated,
+          onSubscriptionCreated,
+          onSubscriptionUpdated,
+          onSubscriptionActive,
+          onSubscriptionCanceled,
+          onSubscriptionRevoked,
+          onSubscriptionUncanceled,
+          onProductCreated,
+          onProductUpdated,
+          onOrganizationUpdated,
+          onBenefitCreated,
+          onBenefitUpdated,
+          onBenefitGrantCreated,
+          onBenefitGrantUpdated,
+          onBenefitGrantRevoked,
+          onCustomerCreated,
+          onCustomerUpdated,
+          onCustomerDeleted,
+          onCustomerStateChanged
+        } = options;
+        if (!ctx.request?.body) {
+          throw new import_api6.APIError("INTERNAL_SERVER_ERROR");
+        }
+        const buf = await ctx.request.text();
+        let event;
+        try {
+          if (!secret) {
+            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+              message: "Polar webhook secret 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 = (0, import_webhooks.validateEvent)(buf, headers, secret);
+        } catch (err) {
+          if (err instanceof Error) {
+            ctx.context.logger.error(`${err.message}`);
+            throw new import_api6.APIError("BAD_REQUEST", {
+              message: `Webhook Error: ${err.message}`
+            });
+          }
+          throw new import_api6.APIError("BAD_REQUEST", {
+            message: `Webhook Error: ${err}`
+          });
+        }
+        try {
+          if (onPayload) {
+            onPayload(event);
+          }
+          switch (event.type) {
+            case "checkout.created":
+              if (onCheckoutCreated) {
+                onCheckoutCreated(event);
+              }
+              break;
+            case "checkout.updated":
+              if (onCheckoutUpdated) {
+                onCheckoutUpdated(event);
+              }
+              break;
+            case "order.created":
+              if (onOrderCreated) {
+                onOrderCreated(event);
+              }
+              break;
+            case "order.paid":
+              if (onOrderPaid) {
+                onOrderPaid(event);
+              }
+              break;
+            case "subscription.created":
+              if (onSubscriptionCreated) {
+                onSubscriptionCreated(event);
+              }
+              break;
+            case "subscription.updated":
+              if (onSubscriptionUpdated) {
+                onSubscriptionUpdated(event);
+              }
+              break;
+            case "subscription.active":
+              if (onSubscriptionActive) {
+                onSubscriptionActive(event);
+              }
+              break;
+            case "subscription.canceled":
+              if (onSubscriptionCanceled) {
+                onSubscriptionCanceled(event);
+              }
+              break;
+            case "subscription.uncanceled":
+              if (onSubscriptionUncanceled) {
+                onSubscriptionUncanceled(event);
+              }
+              break;
+            case "subscription.revoked":
+              if (onSubscriptionRevoked) {
+                onSubscriptionRevoked(event);
+              }
+              break;
+            case "product.created":
+              if (onProductCreated) {
+                onProductCreated(event);
+              }
+              break;
+            case "product.updated":
+              if (onProductUpdated) {
+                onProductUpdated(event);
+              }
+              break;
+            case "organization.updated":
+              if (onOrganizationUpdated) {
+                onOrganizationUpdated(event);
+              }
+              break;
+            case "benefit.created":
+              if (onBenefitCreated) {
+                onBenefitCreated(event);
+              }
+              break;
+            case "benefit.updated":
+              if (onBenefitUpdated) {
+                onBenefitUpdated(event);
+              }
+              break;
+            case "benefit_grant.created":
+              if (onBenefitGrantCreated) {
+                onBenefitGrantCreated(event);
+              }
+              break;
+            case "benefit_grant.updated":
+              if (onBenefitGrantUpdated) {
+                onBenefitGrantUpdated(event);
+              }
+              break;
+            case "benefit_grant.revoked":
+              if (onBenefitGrantRevoked) {
+                onBenefitGrantRevoked(event);
+              }
+              break;
+            case "order.refunded":
+              if (onOrderRefunded) {
+                onOrderRefunded(event);
+              }
+              break;
+            case "refund.created":
+              if (onRefundCreated) {
+                onRefundCreated(event);
+              }
+              break;
+            case "refund.updated":
+              if (onRefundUpdated) {
+                onRefundUpdated(event);
+              }
+              break;
+            case "customer.created":
+              if (onCustomerCreated) {
+                onCustomerCreated(event);
+              }
+              break;
+            case "customer.updated":
+              if (onCustomerUpdated) {
+                onCustomerUpdated(event);
+              }
+              break;
+            case "customer.deleted":
+              if (onCustomerDeleted) {
+                onCustomerDeleted(event);
+              }
+              break;
+            case "customer.state_changed":
+              if (onCustomerStateChanged) {
+                onCustomerStateChanged(event);
+              }
+              break;
+          }
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Polar webhook failed. Error: ${e.message}`
+            );
+          } else {
+            ctx.context.logger.error(`Polar webhook failed. Error: ${e}`);
+          }
+          throw new import_api6.APIError("BAD_REQUEST", {
+            message: "Webhook error: See server logs for more information."
+          });
+        }
+        return ctx.json({ received: true });
+      }
+    )
+  };
+};
+
 // src/index.ts
 var polar = (options) => {
+  const plugins = options.use.map((use) => use(options.client)).reduce((acc, plugin) => {
+    Object.assign(acc, plugin);
+    return acc;
+  }, {});
   return {
     id: "polar",
     endpoints: {
-      polarCheckout: checkout(options),
-      polarCheckoutWithSlug: checkoutWithSlug(options),
-      polarWebhooks: webhooks(options),
-      polarCustomerPortal: customerPortal(options),
-      polarCustomerState: customerState(options)
+      ...plugins
     },
     init() {
       return {
@@ -507,6 +744,11 @@ var polar = (options) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  polar
+  checkout,
+  polar,
+  polarClient,
+  portal,
+  usage,
+  webhooks
 });
 //# sourceMappingURL=index.cjs.map