@commet/better-auth 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1115 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  commet: () => commet,
+  commetClient: () => commetClient,
+  features: () => features,
+  portal: () => portal,
+  seats: () => seats,
+  subscriptions: () => subscriptions,
+  usage: () => usage,
+  webhooks: () => webhooks
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks/customer.ts
+var import_api = require("better-auth/api");
+var onBeforeUserCreate = (options) => async (user, context) => {
+  if (!context || !options.createCustomerOnSignUp) {
+    return;
+  }
+  try {
+    const customParams = options.getCustomerCreateParams ? await options.getCustomerCreateParams({ user }, context.request) : {};
+    if (!user.email) {
+      throw new import_api.APIError("BAD_REQUEST", {
+        message: "An email is required to create a customer"
+      });
+    }
+    const existingCustomers = await options.client.customers.list({
+      search: user.email
+    });
+    const existingCustomer = existingCustomers.data?.find(
+      (c) => c.billingEmail === user.email
+    );
+    if (!existingCustomer) {
+      await options.client.customers.create({
+        email: user.email,
+        legalName: customParams.legalName ?? user.name,
+        displayName: customParams.displayName,
+        domain: customParams.domain,
+        metadata: customParams.metadata
+      });
+    }
+  } catch (e) {
+    if (e instanceof import_api.APIError) {
+      throw e;
+    }
+    if (e instanceof Error) {
+      throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
+        message: `Commet customer creation failed: ${e.message}`
+      });
+    }
+    throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
+      message: "Commet customer creation failed"
+    });
+  }
+};
+var onAfterUserCreate = (options) => async (user, context) => {
+  if (!context || !options.createCustomerOnSignUp) {
+    return;
+  }
+  try {
+    const existingCustomers = await options.client.customers.list({
+      search: user.email
+    });
+    const existingCustomer = existingCustomers.data?.find(
+      (c) => c.billingEmail === user.email
+    );
+    if (existingCustomer && existingCustomer.externalId !== user.id) {
+      await options.client.customers.update({
+        customerId: existingCustomer.id,
+        externalId: user.id
+      });
+    }
+  } catch (e) {
+    if (e instanceof Error) {
+      throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
+        message: `Commet customer update failed: ${e.message}`
+      });
+    }
+    throw new import_api.APIError("INTERNAL_SERVER_ERROR", {
+      message: "Commet customer update failed"
+    });
+  }
+};
+var onUserUpdate = (options) => async (user, context) => {
+  if (!context || !options.createCustomerOnSignUp) {
+    return;
+  }
+  try {
+    const existingCustomers = await options.client.customers.list({
+      externalId: user.id
+    });
+    const existingCustomer = existingCustomers.data?.[0];
+    if (existingCustomer) {
+      await options.client.customers.update({
+        customerId: existingCustomer.id,
+        email: user.email,
+        legalName: user.name ?? void 0
+      });
+    }
+  } catch (e) {
+    if (e instanceof Error) {
+      context.context.logger.error(
+        `Commet customer update failed: ${e.message}`
+      );
+    } else {
+      context.context.logger.error("Commet customer update failed");
+    }
+  }
+};
+var onUserDelete = (options) => async (user, context) => {
+  if (!context || !options.createCustomerOnSignUp) {
+    return;
+  }
+  try {
+    const existingCustomers = await options.client.customers.list({
+      externalId: user.id
+    });
+    const existingCustomer = existingCustomers.data?.[0];
+    if (existingCustomer) {
+      await options.client.customers.archive(existingCustomer.id);
+    }
+  } catch (e) {
+    if (e instanceof Error) {
+      context?.context.logger.error(
+        `Commet customer archive failed: ${e.message}`
+      );
+    } else {
+      context?.context.logger.error("Commet customer archive failed");
+    }
+  }
+};
+
+// src/client.ts
+var commetClient = () => {
+  return {
+    id: "commet-client",
+    $InferServerPlugin: {},
+    getActions: ($fetch) => {
+      return {
+        // Customer Portal
+        customer: {
+          /**
+           * Redirect to the Commet customer portal
+           */
+          portal: async (fetchOptions) => {
+            const res = await $fetch("/commet/portal", {
+              method: "GET",
+              ...fetchOptions
+            });
+            if (res.error) {
+              throw new Error(res.error.message);
+            }
+            const data = res.data;
+            if (data.redirect && typeof window !== "undefined") {
+              window.location.href = data.url;
+            }
+            return data;
+          }
+        },
+        // Subscription management
+        subscription: {
+          /**
+           * Get the current subscription for the authenticated user
+           */
+          get: async (fetchOptions) => {
+            return $fetch("/commet/subscription", {
+              method: "GET",
+              ...fetchOptions
+            });
+          },
+          /**
+           * Change the subscription plan (upgrade/downgrade)
+           */
+          changePlan: async (data, fetchOptions) => {
+            return $fetch("/commet/subscription/change-plan", {
+              method: "POST",
+              body: data,
+              ...fetchOptions
+            });
+          },
+          /**
+           * Cancel the subscription
+           */
+          cancel: async (data, fetchOptions) => {
+            return $fetch("/commet/subscription/cancel", {
+              method: "POST",
+              body: data ?? {},
+              ...fetchOptions
+            });
+          }
+        },
+        // Feature access
+        features: {
+          /**
+           * List all features for the authenticated user
+           */
+          list: async (fetchOptions) => {
+            return $fetch("/commet/features", {
+              method: "GET",
+              ...fetchOptions
+            });
+          },
+          /**
+           * Get a specific feature's access/usage
+           */
+          get: async (data, fetchOptions) => {
+            return $fetch(`/commet/features/${data.code}`, {
+              method: "GET",
+              ...fetchOptions
+            });
+          },
+          /**
+           * Check if a feature is enabled (boolean check)
+           */
+          check: async (data, fetchOptions) => {
+            return $fetch(`/features/${data.code}/check`, {
+              method: "GET",
+              ...fetchOptions
+            });
+          },
+          /**
+           * Check if user can use one more unit of a feature
+           * Returns { allowed: boolean, willBeCharged: boolean }
+           */
+          canUse: async (data, fetchOptions) => {
+            return $fetch(`/features/${data.code}/can-use`, {
+              method: "GET",
+              ...fetchOptions
+            });
+          }
+        },
+        // Usage tracking
+        usage: {
+          /**
+           * Track a usage event for the authenticated user
+           */
+          track: async (data, fetchOptions) => {
+            return $fetch("/commet/usage/track", {
+              method: "POST",
+              body: data,
+              ...fetchOptions
+            });
+          }
+        },
+        // Seat management
+        seats: {
+          /**
+           * List all seat balances for the authenticated user
+           */
+          list: async (fetchOptions) => {
+            return $fetch("/commet/seats", {
+              method: "GET",
+              ...fetchOptions
+            });
+          },
+          /**
+           * Add seats of a specific type
+           */
+          add: async (data, fetchOptions) => {
+            return $fetch("/commet/seats/add", {
+              method: "POST",
+              body: data,
+              ...fetchOptions
+            });
+          },
+          /**
+           * Remove seats of a specific type
+           */
+          remove: async (data, fetchOptions) => {
+            return $fetch("/commet/seats/remove", {
+              method: "POST",
+              body: data,
+              ...fetchOptions
+            });
+          },
+          /**
+           * Set seats to a specific count
+           */
+          set: async (data, fetchOptions) => {
+            return $fetch("/commet/seats/set", {
+              method: "POST",
+              body: data,
+              ...fetchOptions
+            });
+          },
+          /**
+           * Set all seat types at once
+           */
+          setAll: async (data, fetchOptions) => {
+            return $fetch("/commet/seats/set-all", {
+              method: "POST",
+              body: data,
+              ...fetchOptions
+            });
+          }
+        }
+      };
+    }
+  };
+};
+
+// src/plugins/portal.ts
+var import_api2 = require("better-auth/api");
+var import_plugins = require("better-auth/plugins");
+var portal = ({ returnUrl } = {}) => (commet2) => {
+  return {
+    portal: (0, import_plugins.createAuthEndpoint)(
+      "/commet/portal",
+      {
+        method: "GET",
+        use: [import_api2.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api2.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to access the customer portal"
+          });
+        }
+        try {
+          const portalAccess = await commet2.portal.getUrl({
+            externalId: userId
+          });
+          if (!portalAccess.success || !portalAccess.data) {
+            throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+              message: portalAccess.message || "Failed to generate portal URL"
+            });
+          }
+          let portalUrl = portalAccess.data.portalUrl;
+          if (returnUrl) {
+            const url = new URL(portalUrl);
+            url.searchParams.set("return_url", returnUrl);
+            portalUrl = url.toString();
+          }
+          return ctx.json({
+            url: portalUrl,
+            redirect: true
+          });
+        } catch (e) {
+          if (e instanceof import_api2.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet portal access failed: ${e.message}`
+            );
+          }
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to access customer portal"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/subscriptions.ts
+var import_api3 = require("better-auth/api");
+var import_plugins2 = require("better-auth/plugins");
+var import_zod = require("zod");
+var ChangePlanSchema = import_zod.z.object({
+  planId: import_zod.z.string().optional(),
+  slug: import_zod.z.string().optional(),
+  billingInterval: import_zod.z.enum(["monthly", "quarterly", "yearly"]).optional()
+});
+var CancelSchema = import_zod.z.object({
+  reason: import_zod.z.string().optional(),
+  immediate: import_zod.z.boolean().optional()
+});
+var subscriptions = (config = {}) => (commet2) => {
+  return {
+    getSubscription: (0, import_plugins2.createAuthEndpoint)(
+      "/commet/subscription",
+      {
+        method: "GET",
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api3.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to view subscription"
+          });
+        }
+        try {
+          const subscription = await commet2.subscriptions.get(userId);
+          if (!subscription.success) {
+            throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+              message: subscription.message || "Failed to retrieve subscription"
+            });
+          }
+          return ctx.json(subscription.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api3.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription get failed: ${e.message}`
+            );
+          }
+          throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to retrieve subscription"
+          });
+        }
+      }
+    ),
+    changePlan: (0, import_plugins2.createAuthEndpoint)(
+      "/commet/subscription/change-plan",
+      {
+        method: "POST",
+        body: ChangePlanSchema,
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api3.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to change plan"
+          });
+        }
+        let planId = ctx.body.planId;
+        if (ctx.body.slug && !planId) {
+          const plan = config.plans?.find((p) => p.slug === ctx.body.slug);
+          if (!plan) {
+            throw new import_api3.APIError("BAD_REQUEST", {
+              message: `Plan with slug "${ctx.body.slug}" not found`
+            });
+          }
+          planId = plan.planId;
+        }
+        if (!planId) {
+          throw new import_api3.APIError("BAD_REQUEST", {
+            message: "Either planId or slug must be provided"
+          });
+        }
+        try {
+          const currentSub = await commet2.subscriptions.get(userId);
+          if (!currentSub.success || !currentSub.data) {
+            throw new import_api3.APIError("BAD_REQUEST", {
+              message: "No active subscription found"
+            });
+          }
+          const result = await commet2.subscriptions.changePlan({
+            subscriptionId: currentSub.data.id,
+            planId,
+            billingInterval: ctx.body.billingInterval
+          });
+          if (!result.success) {
+            throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to change plan"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api3.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet plan change failed: ${e.message}`
+            );
+          }
+          throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to change plan"
+          });
+        }
+      }
+    ),
+    cancelSubscription: (0, import_plugins2.createAuthEndpoint)(
+      "/commet/subscription/cancel",
+      {
+        method: "POST",
+        body: CancelSchema.optional(),
+        use: [import_api3.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api3.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to cancel subscription"
+          });
+        }
+        try {
+          const currentSub = await commet2.subscriptions.get(userId);
+          if (!currentSub.success || !currentSub.data) {
+            throw new import_api3.APIError("BAD_REQUEST", {
+              message: "No active subscription found"
+            });
+          }
+          const result = await commet2.subscriptions.cancel({
+            subscriptionId: currentSub.data.id,
+            reason: ctx.body?.reason,
+            immediate: ctx.body?.immediate
+          });
+          if (!result.success) {
+            throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to cancel subscription"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api3.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription cancel failed: ${e.message}`
+            );
+          }
+          throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to cancel subscription"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/features.ts
+var import_api4 = require("better-auth/api");
+var import_plugins3 = require("better-auth/plugins");
+var features = (_config = {}) => (commet2) => {
+  return {
+    listFeatures: (0, import_plugins3.createAuthEndpoint)(
+      "/commet/features",
+      {
+        method: "GET",
+        use: [import_api4.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api4.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to view features"
+          });
+        }
+        try {
+          const result = await commet2.features.list(userId);
+          if (!result.success) {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to list features"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api4.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet features list failed: ${e.message}`
+            );
+          }
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to list features"
+          });
+        }
+      }
+    ),
+    getFeature: (0, import_plugins3.createAuthEndpoint)(
+      "/commet/features/:code",
+      {
+        method: "GET",
+        use: [import_api4.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        const code = ctx.params?.code;
+        if (!userId) {
+          throw new import_api4.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to view feature"
+          });
+        }
+        if (!code) {
+          throw new import_api4.APIError("BAD_REQUEST", {
+            message: "Feature code is required"
+          });
+        }
+        try {
+          const result = await commet2.features.get({
+            externalId: userId,
+            code
+          });
+          if (!result.success) {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to get feature"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api4.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet feature get failed: ${e.message}`
+            );
+          }
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to get feature"
+          });
+        }
+      }
+    ),
+    checkFeature: (0, import_plugins3.createAuthEndpoint)(
+      "/commet/features/:code/check",
+      {
+        method: "GET",
+        use: [import_api4.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        const code = ctx.params?.code;
+        if (!userId) {
+          throw new import_api4.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to check feature"
+          });
+        }
+        if (!code) {
+          throw new import_api4.APIError("BAD_REQUEST", {
+            message: "Feature code is required"
+          });
+        }
+        try {
+          const result = await commet2.features.check({
+            externalId: userId,
+            code
+          });
+          if (!result.success) {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to check feature"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api4.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet feature check failed: ${e.message}`
+            );
+          }
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to check feature"
+          });
+        }
+      }
+    ),
+    canUseFeature: (0, import_plugins3.createAuthEndpoint)(
+      "/commet/features/:code/can-use",
+      {
+        method: "GET",
+        use: [import_api4.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        const code = ctx.params?.code;
+        if (!userId) {
+          throw new import_api4.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to check feature usage"
+          });
+        }
+        if (!code) {
+          throw new import_api4.APIError("BAD_REQUEST", {
+            message: "Feature code is required"
+          });
+        }
+        try {
+          const result = await commet2.features.canUse({
+            externalId: userId,
+            code
+          });
+          if (!result.success) {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to check feature usage"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api4.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet feature canUse failed: ${e.message}`
+            );
+          }
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to check feature usage"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/usage.ts
+var import_api5 = require("better-auth/api");
+var import_plugins4 = require("better-auth/plugins");
+var import_zod2 = require("zod");
+var TrackEventSchema = import_zod2.z.object({
+  eventType: import_zod2.z.string(),
+  value: import_zod2.z.number().optional(),
+  idempotencyKey: import_zod2.z.string().optional(),
+  properties: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
+});
+var usage = (_config = {}) => (commet2) => {
+  return {
+    trackUsage: (0, import_plugins4.createAuthEndpoint)(
+      "/commet/usage/track",
+      {
+        method: "POST",
+        body: TrackEventSchema,
+        use: [import_api5.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api5.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to track usage"
+          });
+        }
+        try {
+          const result = await commet2.usage.track(
+            {
+              externalId: userId,
+              eventType: ctx.body.eventType,
+              idempotencyKey: ctx.body.idempotencyKey,
+              properties: ctx.body.properties
+            },
+            {}
+          );
+          if (!result.success) {
+            throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to track usage"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api5.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet usage track failed: ${e.message}`
+            );
+          }
+          throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to track usage"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/seats.ts
+var import_api6 = require("better-auth/api");
+var import_plugins5 = require("better-auth/plugins");
+var import_zod3 = require("zod");
+var SeatOperationSchema = import_zod3.z.object({
+  seatType: import_zod3.z.string(),
+  count: import_zod3.z.number().min(1)
+});
+var SetAllSeatsSchema = import_zod3.z.object({
+  seats: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())
+});
+var seats = (_config = {}) => (commet2) => {
+  return {
+    listSeats: (0, import_plugins5.createAuthEndpoint)(
+      "/commet/seats",
+      {
+        method: "GET",
+        use: [import_api6.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api6.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to view seats"
+          });
+        }
+        try {
+          const result = await commet2.seats.getAllBalances({
+            externalId: userId
+          });
+          if (!result.success) {
+            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to list seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api6.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet seats list failed: ${e.message}`
+            );
+          }
+          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to list seats"
+          });
+        }
+      }
+    ),
+    addSeats: (0, import_plugins5.createAuthEndpoint)(
+      "/commet/seats/add",
+      {
+        method: "POST",
+        body: SeatOperationSchema,
+        use: [import_api6.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api6.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to add seats"
+          });
+        }
+        try {
+          const result = await commet2.seats.add(
+            {
+              externalId: userId,
+              seatType: ctx.body.seatType,
+              count: ctx.body.count
+            },
+            {}
+          );
+          if (!result.success) {
+            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to add seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api6.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(`Commet seats add failed: ${e.message}`);
+          }
+          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to add seats"
+          });
+        }
+      }
+    ),
+    removeSeats: (0, import_plugins5.createAuthEndpoint)(
+      "/commet/seats/remove",
+      {
+        method: "POST",
+        body: SeatOperationSchema,
+        use: [import_api6.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api6.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to remove seats"
+          });
+        }
+        try {
+          const result = await commet2.seats.remove(
+            {
+              externalId: userId,
+              seatType: ctx.body.seatType,
+              count: ctx.body.count
+            },
+            {}
+          );
+          if (!result.success) {
+            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to remove seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api6.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet seats remove failed: ${e.message}`
+            );
+          }
+          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to remove seats"
+          });
+        }
+      }
+    ),
+    setSeats: (0, import_plugins5.createAuthEndpoint)(
+      "/commet/seats/set",
+      {
+        method: "POST",
+        body: SeatOperationSchema,
+        use: [import_api6.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api6.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to set seats"
+          });
+        }
+        try {
+          const result = await commet2.seats.set(
+            {
+              externalId: userId,
+              seatType: ctx.body.seatType,
+              count: ctx.body.count
+            },
+            {}
+          );
+          if (!result.success) {
+            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to set seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api6.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(`Commet seats set failed: ${e.message}`);
+          }
+          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to set seats"
+          });
+        }
+      }
+    ),
+    setAllSeats: (0, import_plugins5.createAuthEndpoint)(
+      "/commet/seats/set-all",
+      {
+        method: "POST",
+        body: SetAllSeatsSchema,
+        use: [import_api6.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api6.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to set seats"
+          });
+        }
+        try {
+          const result = await commet2.seats.setAll(
+            {
+              externalId: userId,
+              seats: ctx.body.seats
+            },
+            {}
+          );
+          if (!result.success) {
+            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to set all seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api6.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet seats set-all failed: ${e.message}`
+            );
+          }
+          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to set all seats"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/webhooks.ts
+var import_api7 = require("better-auth/api");
+var EVENT_HANDLER_MAP = {
+  "subscription.created": "onSubscriptionCreated",
+  "subscription.activated": "onSubscriptionActivated",
+  "subscription.canceled": "onSubscriptionCanceled",
+  "subscription.updated": "onSubscriptionUpdated"
+};
+var webhooks = (config) => (commet2) => {
+  return {
+    commetWebhooks: (0, import_api7.createAuthEndpoint)(
+      "/commet/webhooks",
+      {
+        method: "POST",
+        metadata: {
+          isAction: false
+        },
+        cloneRequest: true
+      },
+      async (ctx) => {
+        if (!ctx.request?.body) {
+          throw new import_api7.APIError("BAD_REQUEST", {
+            message: "Request body is required"
+          });
+        }
+        const rawBody = await ctx.request.text();
+        const signature = ctx.request.headers.get("x-commet-signature");
+        const payload = commet2.webhooks.verifyAndParse({
+          rawBody,
+          signature,
+          secret: config.secret
+        });
+        if (!payload) {
+          ctx.context.logger.error("Invalid webhook signature");
+          throw new import_api7.APIError("UNAUTHORIZED", {
+            message: "Invalid webhook signature"
+          });
+        }
+        try {
+          const handlerKey = EVENT_HANDLER_MAP[payload.event];
+          if (handlerKey) {
+            const handler = config[handlerKey];
+            if (handler) {
+              await handler(payload);
+            }
+          }
+          if (config.onPayload) {
+            await config.onPayload(payload);
+          }
+          return ctx.json({ received: true });
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet webhook handler error: ${e.message}`
+            );
+          } else {
+            ctx.context.logger.error("Commet webhook handler error");
+          }
+          throw new import_api7.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Webhook handler error"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/index.ts
+var commet = (options) => {
+  const plugins = options.use.map((use) => use(options.client)).reduce((acc, plugin) => {
+    Object.assign(acc, plugin);
+    return acc;
+  }, {});
+  return {
+    id: "commet",
+    endpoints: {
+      ...plugins
+    },
+    init() {
+      return {
+        options: {
+          databaseHooks: {
+            user: {
+              create: {
+                before: onBeforeUserCreate(options),
+                after: onAfterUserCreate(options)
+              },
+              update: {
+                after: onUserUpdate(options)
+              },
+              delete: {
+                after: onUserDelete(options)
+              }
+            }
+          }
+        }
+      };
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commet,
+  commetClient,
+  features,
+  portal,
+  seats,
+  subscriptions,
+  usage,
+  webhooks
+});
+//# sourceMappingURL=index.cjs.map