@commet/better-auth 1.0.0

package/dist/index.js

@@ -0,0 +1,1081 @@
+// src/hooks/customer.ts
+import { APIError } from "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 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 APIError) {
+      throw e;
+    }
+    if (e instanceof Error) {
+      throw new APIError("INTERNAL_SERVER_ERROR", {
+        message: `Commet customer creation failed: ${e.message}`
+      });
+    }
+    throw new 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 APIError("INTERNAL_SERVER_ERROR", {
+        message: `Commet customer update failed: ${e.message}`
+      });
+    }
+    throw new 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
+import { APIError as APIError2, sessionMiddleware } from "better-auth/api";
+import { createAuthEndpoint } from "better-auth/plugins";
+var portal = ({ returnUrl } = {}) => (commet2) => {
+  return {
+    portal: createAuthEndpoint(
+      "/commet/portal",
+      {
+        method: "GET",
+        use: [sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError2("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 APIError2("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 APIError2) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet portal access failed: ${e.message}`
+            );
+          }
+          throw new APIError2("INTERNAL_SERVER_ERROR", {
+            message: "Failed to access customer portal"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/subscriptions.ts
+import { APIError as APIError3, sessionMiddleware as sessionMiddleware2 } from "better-auth/api";
+import { createAuthEndpoint as createAuthEndpoint2 } from "better-auth/plugins";
+import { z } from "zod";
+var ChangePlanSchema = z.object({
+  planId: z.string().optional(),
+  slug: z.string().optional(),
+  billingInterval: z.enum(["monthly", "quarterly", "yearly"]).optional()
+});
+var CancelSchema = z.object({
+  reason: z.string().optional(),
+  immediate: z.boolean().optional()
+});
+var subscriptions = (config = {}) => (commet2) => {
+  return {
+    getSubscription: createAuthEndpoint2(
+      "/commet/subscription",
+      {
+        method: "GET",
+        use: [sessionMiddleware2]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError3("UNAUTHORIZED", {
+            message: "You must be logged in to view subscription"
+          });
+        }
+        try {
+          const subscription = await commet2.subscriptions.get(userId);
+          if (!subscription.success) {
+            throw new APIError3("INTERNAL_SERVER_ERROR", {
+              message: subscription.message || "Failed to retrieve subscription"
+            });
+          }
+          return ctx.json(subscription.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError3) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription get failed: ${e.message}`
+            );
+          }
+          throw new APIError3("INTERNAL_SERVER_ERROR", {
+            message: "Failed to retrieve subscription"
+          });
+        }
+      }
+    ),
+    changePlan: createAuthEndpoint2(
+      "/commet/subscription/change-plan",
+      {
+        method: "POST",
+        body: ChangePlanSchema,
+        use: [sessionMiddleware2]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError3("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 APIError3("BAD_REQUEST", {
+              message: `Plan with slug "${ctx.body.slug}" not found`
+            });
+          }
+          planId = plan.planId;
+        }
+        if (!planId) {
+          throw new APIError3("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 APIError3("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 APIError3("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to change plan"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError3) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet plan change failed: ${e.message}`
+            );
+          }
+          throw new APIError3("INTERNAL_SERVER_ERROR", {
+            message: "Failed to change plan"
+          });
+        }
+      }
+    ),
+    cancelSubscription: createAuthEndpoint2(
+      "/commet/subscription/cancel",
+      {
+        method: "POST",
+        body: CancelSchema.optional(),
+        use: [sessionMiddleware2]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError3("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 APIError3("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 APIError3("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to cancel subscription"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError3) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription cancel failed: ${e.message}`
+            );
+          }
+          throw new APIError3("INTERNAL_SERVER_ERROR", {
+            message: "Failed to cancel subscription"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/features.ts
+import { APIError as APIError4, sessionMiddleware as sessionMiddleware3 } from "better-auth/api";
+import { createAuthEndpoint as createAuthEndpoint3 } from "better-auth/plugins";
+var features = (_config = {}) => (commet2) => {
+  return {
+    listFeatures: createAuthEndpoint3(
+      "/commet/features",
+      {
+        method: "GET",
+        use: [sessionMiddleware3]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError4("UNAUTHORIZED", {
+            message: "You must be logged in to view features"
+          });
+        }
+        try {
+          const result = await commet2.features.list(userId);
+          if (!result.success) {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to list features"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError4) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet features list failed: ${e.message}`
+            );
+          }
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
+            message: "Failed to list features"
+          });
+        }
+      }
+    ),
+    getFeature: createAuthEndpoint3(
+      "/commet/features/:code",
+      {
+        method: "GET",
+        use: [sessionMiddleware3]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        const code = ctx.params?.code;
+        if (!userId) {
+          throw new APIError4("UNAUTHORIZED", {
+            message: "You must be logged in to view feature"
+          });
+        }
+        if (!code) {
+          throw new APIError4("BAD_REQUEST", {
+            message: "Feature code is required"
+          });
+        }
+        try {
+          const result = await commet2.features.get({
+            externalId: userId,
+            code
+          });
+          if (!result.success) {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to get feature"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError4) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet feature get failed: ${e.message}`
+            );
+          }
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
+            message: "Failed to get feature"
+          });
+        }
+      }
+    ),
+    checkFeature: createAuthEndpoint3(
+      "/commet/features/:code/check",
+      {
+        method: "GET",
+        use: [sessionMiddleware3]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        const code = ctx.params?.code;
+        if (!userId) {
+          throw new APIError4("UNAUTHORIZED", {
+            message: "You must be logged in to check feature"
+          });
+        }
+        if (!code) {
+          throw new APIError4("BAD_REQUEST", {
+            message: "Feature code is required"
+          });
+        }
+        try {
+          const result = await commet2.features.check({
+            externalId: userId,
+            code
+          });
+          if (!result.success) {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to check feature"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError4) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet feature check failed: ${e.message}`
+            );
+          }
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
+            message: "Failed to check feature"
+          });
+        }
+      }
+    ),
+    canUseFeature: createAuthEndpoint3(
+      "/commet/features/:code/can-use",
+      {
+        method: "GET",
+        use: [sessionMiddleware3]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        const code = ctx.params?.code;
+        if (!userId) {
+          throw new APIError4("UNAUTHORIZED", {
+            message: "You must be logged in to check feature usage"
+          });
+        }
+        if (!code) {
+          throw new APIError4("BAD_REQUEST", {
+            message: "Feature code is required"
+          });
+        }
+        try {
+          const result = await commet2.features.canUse({
+            externalId: userId,
+            code
+          });
+          if (!result.success) {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to check feature usage"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError4) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet feature canUse failed: ${e.message}`
+            );
+          }
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
+            message: "Failed to check feature usage"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/usage.ts
+import { APIError as APIError5, sessionMiddleware as sessionMiddleware4 } from "better-auth/api";
+import { createAuthEndpoint as createAuthEndpoint4 } from "better-auth/plugins";
+import { z as z2 } from "zod";
+var TrackEventSchema = z2.object({
+  eventType: z2.string(),
+  value: z2.number().optional(),
+  idempotencyKey: z2.string().optional(),
+  properties: z2.record(z2.string(), z2.string()).optional()
+});
+var usage = (_config = {}) => (commet2) => {
+  return {
+    trackUsage: createAuthEndpoint4(
+      "/commet/usage/track",
+      {
+        method: "POST",
+        body: TrackEventSchema,
+        use: [sessionMiddleware4]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError5("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 APIError5("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to track usage"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError5) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet usage track failed: ${e.message}`
+            );
+          }
+          throw new APIError5("INTERNAL_SERVER_ERROR", {
+            message: "Failed to track usage"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/seats.ts
+import { APIError as APIError6, sessionMiddleware as sessionMiddleware5 } from "better-auth/api";
+import { createAuthEndpoint as createAuthEndpoint5 } from "better-auth/plugins";
+import { z as z3 } from "zod";
+var SeatOperationSchema = z3.object({
+  seatType: z3.string(),
+  count: z3.number().min(1)
+});
+var SetAllSeatsSchema = z3.object({
+  seats: z3.record(z3.string(), z3.number())
+});
+var seats = (_config = {}) => (commet2) => {
+  return {
+    listSeats: createAuthEndpoint5(
+      "/commet/seats",
+      {
+        method: "GET",
+        use: [sessionMiddleware5]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError6("UNAUTHORIZED", {
+            message: "You must be logged in to view seats"
+          });
+        }
+        try {
+          const result = await commet2.seats.getAllBalances({
+            externalId: userId
+          });
+          if (!result.success) {
+            throw new APIError6("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to list seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError6) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet seats list failed: ${e.message}`
+            );
+          }
+          throw new APIError6("INTERNAL_SERVER_ERROR", {
+            message: "Failed to list seats"
+          });
+        }
+      }
+    ),
+    addSeats: createAuthEndpoint5(
+      "/commet/seats/add",
+      {
+        method: "POST",
+        body: SeatOperationSchema,
+        use: [sessionMiddleware5]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError6("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 APIError6("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to add seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError6) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(`Commet seats add failed: ${e.message}`);
+          }
+          throw new APIError6("INTERNAL_SERVER_ERROR", {
+            message: "Failed to add seats"
+          });
+        }
+      }
+    ),
+    removeSeats: createAuthEndpoint5(
+      "/commet/seats/remove",
+      {
+        method: "POST",
+        body: SeatOperationSchema,
+        use: [sessionMiddleware5]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError6("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 APIError6("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to remove seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError6) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet seats remove failed: ${e.message}`
+            );
+          }
+          throw new APIError6("INTERNAL_SERVER_ERROR", {
+            message: "Failed to remove seats"
+          });
+        }
+      }
+    ),
+    setSeats: createAuthEndpoint5(
+      "/commet/seats/set",
+      {
+        method: "POST",
+        body: SeatOperationSchema,
+        use: [sessionMiddleware5]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError6("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 APIError6("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to set seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError6) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(`Commet seats set failed: ${e.message}`);
+          }
+          throw new APIError6("INTERNAL_SERVER_ERROR", {
+            message: "Failed to set seats"
+          });
+        }
+      }
+    ),
+    setAllSeats: createAuthEndpoint5(
+      "/commet/seats/set-all",
+      {
+        method: "POST",
+        body: SetAllSeatsSchema,
+        use: [sessionMiddleware5]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError6("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 APIError6("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to set all seats"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError6) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet seats set-all failed: ${e.message}`
+            );
+          }
+          throw new APIError6("INTERNAL_SERVER_ERROR", {
+            message: "Failed to set all seats"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/webhooks.ts
+import { APIError as APIError7, createAuthEndpoint as createAuthEndpoint6 } from "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: createAuthEndpoint6(
+      "/commet/webhooks",
+      {
+        method: "POST",
+        metadata: {
+          isAction: false
+        },
+        cloneRequest: true
+      },
+      async (ctx) => {
+        if (!ctx.request?.body) {
+          throw new APIError7("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 APIError7("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 APIError7("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)
+              }
+            }
+          }
+        }
+      };
+    }
+  };
+};
+export {
+  commet,
+  commetClient,
+  features,
+  portal,
+  seats,
+  subscriptions,
+  usage,
+  webhooks
+};
+//# sourceMappingURL=index.js.map