@commet/better-auth 1.3.2 → 1.3.4

package/dist/index.js

@@ -275,185 +275,37 @@ var commetClient = () => {
   };
 };
 
-// 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 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"
-          });
-        }
-      }
-    ),
-    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";
+import {
+  APIError as APIError2,
+  createAuthEndpoint,
+  sessionMiddleware
+} from "better-auth/api";
 var features = (_config = {}) => (commet2) => {
   return {
-    listFeatures: createAuthEndpoint3(
+    listFeatures: createAuthEndpoint(
       "/commet/features",
       {
         method: "GET",
-        use: [sessionMiddleware3]
+        use: [sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new APIError4("UNAUTHORIZED", {
+          throw new APIError2("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", {
+            throw new APIError2("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to list features"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError4) {
+          if (e instanceof APIError2) {
             throw e;
           }
           if (e instanceof Error) {
@@ -461,28 +313,28 @@ var features = (_config = {}) => (commet2) => {
               `Commet features list failed: ${e.message}`
             );
           }
-          throw new APIError4("INTERNAL_SERVER_ERROR", {
+          throw new APIError2("INTERNAL_SERVER_ERROR", {
             message: "Failed to list features"
           });
         }
       }
     ),
-    getFeature: createAuthEndpoint3(
+    getFeature: createAuthEndpoint(
       "/commet/features/:code",
       {
         method: "GET",
-        use: [sessionMiddleware3]
+        use: [sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         const code = ctx.params?.code;
         if (!userId) {
-          throw new APIError4("UNAUTHORIZED", {
+          throw new APIError2("UNAUTHORIZED", {
             message: "You must be logged in to view feature"
           });
         }
         if (!code) {
-          throw new APIError4("BAD_REQUEST", {
+          throw new APIError2("BAD_REQUEST", {
             message: "Feature code is required"
           });
         }
@@ -492,13 +344,13 @@ var features = (_config = {}) => (commet2) => {
             code
           });
           if (!result.success) {
-            throw new APIError4("INTERNAL_SERVER_ERROR", {
+            throw new APIError2("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to get feature"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError4) {
+          if (e instanceof APIError2) {
             throw e;
           }
           if (e instanceof Error) {
@@ -506,28 +358,28 @@ var features = (_config = {}) => (commet2) => {
               `Commet feature get failed: ${e.message}`
             );
           }
-          throw new APIError4("INTERNAL_SERVER_ERROR", {
+          throw new APIError2("INTERNAL_SERVER_ERROR", {
             message: "Failed to get feature"
           });
         }
       }
     ),
-    checkFeature: createAuthEndpoint3(
+    checkFeature: createAuthEndpoint(
       "/commet/features/:code/check",
       {
         method: "GET",
-        use: [sessionMiddleware3]
+        use: [sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         const code = ctx.params?.code;
         if (!userId) {
-          throw new APIError4("UNAUTHORIZED", {
+          throw new APIError2("UNAUTHORIZED", {
             message: "You must be logged in to check feature"
           });
         }
         if (!code) {
-          throw new APIError4("BAD_REQUEST", {
+          throw new APIError2("BAD_REQUEST", {
             message: "Feature code is required"
           });
         }
@@ -537,13 +389,13 @@ var features = (_config = {}) => (commet2) => {
             code
           });
           if (!result.success) {
-            throw new APIError4("INTERNAL_SERVER_ERROR", {
+            throw new APIError2("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to check feature"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError4) {
+          if (e instanceof APIError2) {
             throw e;
           }
           if (e instanceof Error) {
@@ -551,28 +403,28 @@ var features = (_config = {}) => (commet2) => {
               `Commet feature check failed: ${e.message}`
             );
           }
-          throw new APIError4("INTERNAL_SERVER_ERROR", {
+          throw new APIError2("INTERNAL_SERVER_ERROR", {
             message: "Failed to check feature"
           });
         }
       }
     ),
-    canUseFeature: createAuthEndpoint3(
+    canUseFeature: createAuthEndpoint(
       "/commet/features/:code/can-use",
       {
         method: "GET",
-        use: [sessionMiddleware3]
+        use: [sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         const code = ctx.params?.code;
         if (!userId) {
-          throw new APIError4("UNAUTHORIZED", {
+          throw new APIError2("UNAUTHORIZED", {
             message: "You must be logged in to check feature usage"
           });
         }
         if (!code) {
-          throw new APIError4("BAD_REQUEST", {
+          throw new APIError2("BAD_REQUEST", {
             message: "Feature code is required"
           });
         }
@@ -582,13 +434,13 @@ var features = (_config = {}) => (commet2) => {
             code
           });
           if (!result.success) {
-            throw new APIError4("INTERNAL_SERVER_ERROR", {
+            throw new APIError2("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to check feature usage"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError4) {
+          if (e instanceof APIError2) {
             throw e;
           }
           if (e instanceof Error) {
@@ -596,7 +448,7 @@ var features = (_config = {}) => (commet2) => {
               `Commet feature canUse failed: ${e.message}`
             );
           }
-          throw new APIError4("INTERNAL_SERVER_ERROR", {
+          throw new APIError2("INTERNAL_SERVER_ERROR", {
             message: "Failed to check feature usage"
           });
         }
@@ -605,60 +457,57 @@ var features = (_config = {}) => (commet2) => {
   };
 };
 
-// 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({
-  feature: z2.string(),
-  value: z2.number().optional(),
-  idempotencyKey: z2.string().optional(),
-  properties: z2.record(z2.string(), z2.string()).optional()
-});
-var usage = (_config = {}) => (commet2) => {
+// src/plugins/portal.ts
+import {
+  APIError as APIError3,
+  createAuthEndpoint as createAuthEndpoint2,
+  sessionMiddleware as sessionMiddleware2
+} from "better-auth/api";
+var portal = ({ returnUrl } = {}) => (commet2) => {
   return {
-    trackUsage: createAuthEndpoint4(
-      "/commet/usage/track",
+    portal: createAuthEndpoint2(
+      "/commet/portal",
       {
-        method: "POST",
-        body: TrackEventSchema,
-        use: [sessionMiddleware4]
+        method: "GET",
+        use: [sessionMiddleware2]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new APIError5("UNAUTHORIZED", {
-            message: "You must be logged in to track usage"
+          throw new APIError3("UNAUTHORIZED", {
+            message: "You must be logged in to access the customer portal"
           });
         }
         try {
-          const result = await commet2.usage.track(
-            {
-              externalId: userId,
-              feature: ctx.body.feature,
-              value: ctx.body.value,
-              idempotencyKey: ctx.body.idempotencyKey,
-              properties: ctx.body.properties
-            },
-            {}
-          );
-          if (!result.success) {
-            throw new APIError5("INTERNAL_SERVER_ERROR", {
-              message: result.message || "Failed to track usage"
+          const portalAccess = await commet2.portal.getUrl({
+            externalId: userId
+          });
+          if (!portalAccess.success || !portalAccess.data) {
+            throw new APIError3("INTERNAL_SERVER_ERROR", {
+              message: portalAccess.message || "Failed to generate portal URL"
             });
           }
-          return ctx.json(result.data ?? null);
+          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 APIError5) {
+          if (e instanceof APIError3) {
             throw e;
           }
           if (e instanceof Error) {
             ctx.context.logger.error(
-              `Commet usage track failed: ${e.message}`
+              `Commet portal access failed: ${e.message}`
             );
           }
-          throw new APIError5("INTERNAL_SERVER_ERROR", {
-            message: "Failed to track usage"
+          throw new APIError3("INTERNAL_SERVER_ERROR", {
+            message: "Failed to access customer portal"
           });
         }
       }
@@ -667,28 +516,31 @@ var usage = (_config = {}) => (commet2) => {
 };
 
 // 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)
+import {
+  APIError as APIError4,
+  createAuthEndpoint as createAuthEndpoint3,
+  sessionMiddleware as sessionMiddleware3
+} from "better-auth/api";
+import { z } from "zod";
+var SeatOperationSchema = z.object({
+  seatType: z.string(),
+  count: z.number().min(1)
 });
-var SetAllSeatsSchema = z3.object({
-  seats: z3.record(z3.string(), z3.number())
+var SetAllSeatsSchema = z.object({
+  seats: z.record(z.string(), z.number())
 });
 var seats = (_config = {}) => (commet2) => {
   return {
-    listSeats: createAuthEndpoint5(
+    listSeats: createAuthEndpoint3(
       "/commet/seats",
       {
         method: "GET",
-        use: [sessionMiddleware5]
+        use: [sessionMiddleware3]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new APIError6("UNAUTHORIZED", {
+          throw new APIError4("UNAUTHORIZED", {
             message: "You must be logged in to view seats"
           });
         }
@@ -697,13 +549,13 @@ var seats = (_config = {}) => (commet2) => {
             externalId: userId
           });
           if (!result.success) {
-            throw new APIError6("INTERNAL_SERVER_ERROR", {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to list seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError6) {
+          if (e instanceof APIError4) {
             throw e;
           }
           if (e instanceof Error) {
@@ -711,23 +563,23 @@ var seats = (_config = {}) => (commet2) => {
               `Commet seats list failed: ${e.message}`
             );
           }
-          throw new APIError6("INTERNAL_SERVER_ERROR", {
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
             message: "Failed to list seats"
           });
         }
       }
     ),
-    addSeats: createAuthEndpoint5(
+    addSeats: createAuthEndpoint3(
       "/commet/seats/add",
       {
         method: "POST",
         body: SeatOperationSchema,
-        use: [sessionMiddleware5]
+        use: [sessionMiddleware3]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new APIError6("UNAUTHORIZED", {
+          throw new APIError4("UNAUTHORIZED", {
             message: "You must be logged in to add seats"
           });
         }
@@ -741,35 +593,35 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new APIError6("INTERNAL_SERVER_ERROR", {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to add seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError6) {
+          if (e instanceof APIError4) {
             throw e;
           }
           if (e instanceof Error) {
             ctx.context.logger.error(`Commet seats add failed: ${e.message}`);
           }
-          throw new APIError6("INTERNAL_SERVER_ERROR", {
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
             message: "Failed to add seats"
           });
         }
       }
     ),
-    removeSeats: createAuthEndpoint5(
+    removeSeats: createAuthEndpoint3(
       "/commet/seats/remove",
       {
         method: "POST",
         body: SeatOperationSchema,
-        use: [sessionMiddleware5]
+        use: [sessionMiddleware3]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new APIError6("UNAUTHORIZED", {
+          throw new APIError4("UNAUTHORIZED", {
             message: "You must be logged in to remove seats"
           });
         }
@@ -783,13 +635,13 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new APIError6("INTERNAL_SERVER_ERROR", {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to remove seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError6) {
+          if (e instanceof APIError4) {
             throw e;
           }
           if (e instanceof Error) {
@@ -797,23 +649,23 @@ var seats = (_config = {}) => (commet2) => {
               `Commet seats remove failed: ${e.message}`
             );
           }
-          throw new APIError6("INTERNAL_SERVER_ERROR", {
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
             message: "Failed to remove seats"
           });
         }
       }
     ),
-    setSeats: createAuthEndpoint5(
+    setSeats: createAuthEndpoint3(
       "/commet/seats/set",
       {
         method: "POST",
         body: SeatOperationSchema,
-        use: [sessionMiddleware5]
+        use: [sessionMiddleware3]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new APIError6("UNAUTHORIZED", {
+          throw new APIError4("UNAUTHORIZED", {
             message: "You must be logged in to set seats"
           });
         }
@@ -827,35 +679,35 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new APIError6("INTERNAL_SERVER_ERROR", {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to set seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError6) {
+          if (e instanceof APIError4) {
             throw e;
           }
           if (e instanceof Error) {
             ctx.context.logger.error(`Commet seats set failed: ${e.message}`);
           }
-          throw new APIError6("INTERNAL_SERVER_ERROR", {
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
             message: "Failed to set seats"
           });
         }
       }
     ),
-    setAllSeats: createAuthEndpoint5(
+    setAllSeats: createAuthEndpoint3(
       "/commet/seats/set-all",
       {
         method: "POST",
         body: SetAllSeatsSchema,
-        use: [sessionMiddleware5]
+        use: [sessionMiddleware3]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new APIError6("UNAUTHORIZED", {
+          throw new APIError4("UNAUTHORIZED", {
             message: "You must be logged in to set seats"
           });
         }
@@ -868,13 +720,13 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new APIError6("INTERNAL_SERVER_ERROR", {
+            throw new APIError4("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to set all seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof APIError6) {
+          if (e instanceof APIError4) {
             throw e;
           }
           if (e instanceof Error) {
@@ -882,7 +734,7 @@ var seats = (_config = {}) => (commet2) => {
               `Commet seats set-all failed: ${e.message}`
             );
           }
-          throw new APIError6("INTERNAL_SERVER_ERROR", {
+          throw new APIError4("INTERNAL_SERVER_ERROR", {
             message: "Failed to set all seats"
           });
         }
@@ -891,6 +743,169 @@ var seats = (_config = {}) => (commet2) => {
   };
 };
 
+// src/plugins/subscriptions.ts
+import {
+  APIError as APIError5,
+  createAuthEndpoint as createAuthEndpoint4,
+  sessionMiddleware as sessionMiddleware4
+} from "better-auth/api";
+import { z as z2 } from "zod";
+var CancelSchema = z2.object({
+  reason: z2.string().optional(),
+  immediate: z2.boolean().optional()
+});
+var subscriptions = (_config = {}) => (commet2) => {
+  return {
+    getSubscription: createAuthEndpoint4(
+      "/commet/subscription",
+      {
+        method: "GET",
+        use: [sessionMiddleware4]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError5("UNAUTHORIZED", {
+            message: "You must be logged in to view subscription"
+          });
+        }
+        try {
+          const subscription = await commet2.subscriptions.get(userId);
+          if (!subscription.success) {
+            throw new APIError5("INTERNAL_SERVER_ERROR", {
+              message: subscription.message || "Failed to retrieve subscription"
+            });
+          }
+          return ctx.json(subscription.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError5) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription get failed: ${e.message}`
+            );
+          }
+          throw new APIError5("INTERNAL_SERVER_ERROR", {
+            message: "Failed to retrieve subscription"
+          });
+        }
+      }
+    ),
+    cancelSubscription: createAuthEndpoint4(
+      "/commet/subscription/cancel",
+      {
+        method: "POST",
+        body: CancelSchema.optional(),
+        use: [sessionMiddleware4]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError5("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 APIError5("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 APIError5("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to cancel subscription"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError5) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription cancel failed: ${e.message}`
+            );
+          }
+          throw new APIError5("INTERNAL_SERVER_ERROR", {
+            message: "Failed to cancel subscription"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/usage.ts
+import {
+  APIError as APIError6,
+  createAuthEndpoint as createAuthEndpoint5,
+  sessionMiddleware as sessionMiddleware5
+} from "better-auth/api";
+import { z as z3 } from "zod";
+var TrackEventSchema = z3.object({
+  feature: z3.string(),
+  value: z3.number().optional(),
+  idempotencyKey: z3.string().optional(),
+  properties: z3.record(z3.string(), z3.string()).optional()
+});
+var usage = (_config = {}) => (commet2) => {
+  return {
+    trackUsage: createAuthEndpoint5(
+      "/commet/usage/track",
+      {
+        method: "POST",
+        body: TrackEventSchema,
+        use: [sessionMiddleware5]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new APIError6("UNAUTHORIZED", {
+            message: "You must be logged in to track usage"
+          });
+        }
+        try {
+          const result = await commet2.usage.track(
+            {
+              externalId: userId,
+              feature: ctx.body.feature,
+              value: ctx.body.value,
+              idempotencyKey: ctx.body.idempotencyKey,
+              properties: ctx.body.properties
+            },
+            {}
+          );
+          if (!result.success) {
+            throw new APIError6("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to track usage"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof APIError6) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet usage track failed: ${e.message}`
+            );
+          }
+          throw new APIError6("INTERNAL_SERVER_ERROR", {
+            message: "Failed to track usage"
+          });
+        }
+      }
+    )
+  };
+};
+
 // src/plugins/webhooks.ts
 import { APIError as APIError7, createAuthEndpoint as createAuthEndpoint6 } from "better-auth/api";
 var EVENT_HANDLER_MAP = {