autumn-js 0.1.34 → 0.1.36

package/dist/libraries/backend/better-auth.mjs

@@ -1,35 +1,142 @@
+import {
+  getIdentityContext,
+  getOrganizationContext,
+  scopeContainsOrg
+} from "./chunk-SRJD6EXQ.mjs";
 import {
   secretKeyCheck
 } from "./chunk-UNZHJTEY.mjs";
 import {
   createRouterWithOptions
-} from "./chunk-WBHGLFLE.mjs";
-import "./chunk-SRHT6RDB.mjs";
-import "./chunk-7OEFNFGZ.mjs";
-import "./chunk-D5C5Q5FZ.mjs";
-import "./chunk-SVTPC45F.mjs";
-import "./chunk-F3S66STP.mjs";
+} from "./chunk-4MEEJLXG.mjs";
+import "./chunk-PO4EL4BW.mjs";
+import "./chunk-MHIUO3ST.mjs";
+import "./chunk-USQ76FYI.mjs";
+import "./chunk-LOSIWWM2.mjs";
+import "./chunk-35N7BIAE.mjs";
 import {
-  AttachParamsSchema,
   Autumn,
-  BillingPortalParamsSchema,
-  CancelParamsSchema,
-  CheckParamsSchema,
-  CheckoutParamsSchema,
-  CreateReferralCodeParamsSchema,
   CustomerExpandEnum,
-  RedeemReferralCodeParamsSchema,
-  TrackParamsSchema
-} from "./chunk-ENRZQDOT.mjs";
+  QueryRangeEnum
+} from "./chunk-QOJMX7ML.mjs";
 import "./chunk-2TEL6LR5.mjs";
 import "./chunk-KSG3E4Q2.mjs";
 
 // src/libraries/backend/better-auth.ts
+import { getSessionFromCtx } from "better-auth/api";
 import { createAuthEndpoint } from "better-auth/plugins";
-import { APIError, createEndpoint } from "better-call";
+import {
+  APIError,
+  createEndpoint
+} from "better-call";
 import { findRoute } from "rou3";
-import { getSessionFromCtx, sessionMiddleware } from "better-auth/api";
+import { z as z5 } from "zod/v4";
+
+// src/libraries/react/client/types/clientAttachTypes.ts
 import { z } from "zod/v4";
+var AttachFeatureOptionsSchema = z.object({
+  featureId: z.string(),
+  quantity: z.number()
+});
+var AttachParamsSchema = z.object({
+  productId: z.string().optional(),
+  entityId: z.string().optional(),
+  options: z.array(AttachFeatureOptionsSchema).optional(),
+  productIds: z.array(z.string()).optional(),
+  freeTrial: z.boolean().optional(),
+  successUrl: z.string().optional(),
+  metadata: z.record(z.string(), z.string()).optional(),
+  forceCheckout: z.boolean().optional(),
+  /**
+   * @deprecated This field is deprecated and will be removed in a future version.
+   */
+  dialog: z.any().optional().describe(
+    "DEPRECATED: This field is deprecated and will be removed in a future version. Please use the checkout() method instead."
+  ),
+  entityData: z.any().optional(),
+  openInNewTab: z.boolean().optional(),
+  reward: z.string().optional(),
+  checkoutSessionParams: z.record(z.string(), z.any()).optional()
+});
+var CheckoutParamsSchema = z.object({
+  productId: z.string().optional(),
+  productIds: z.array(z.string()).optional(),
+  entityId: z.string().optional(),
+  entityData: z.any().optional(),
+  options: z.array(AttachFeatureOptionsSchema).optional(),
+  successUrl: z.string().optional(),
+  openInNewTab: z.boolean().optional(),
+  dialog: z.any().optional(),
+  forceCheckout: z.boolean().optional(),
+  checkoutSessionParams: z.record(z.string(), z.any()).optional(),
+  reward: z.string().optional()
+});
+
+// src/libraries/react/client/types/clientEntTypes.ts
+import { z as z2 } from "zod/v4";
+var CreateEntityParamsSchema = z2.object({
+  id: z2.string(),
+  name: z2.string().optional(),
+  featureId: z2.string()
+});
+var GetEntityParamsSchema = z2.object({
+  expand: z2.array(z2.string()).optional()
+});
+var EntityDataParamsSchema = z2.object({
+  name: z2.string().optional(),
+  featureId: z2.string()
+});
+
+// src/libraries/react/client/types/clientGenTypes.ts
+import { z as z3 } from "zod/v4";
+var CancelParamsSchema = z3.object({
+  productId: z3.string(),
+  entityId: z3.string().optional(),
+  cancelImmediately: z3.boolean().optional()
+});
+var CheckParamsSchema = z3.object({
+  featureId: z3.string().optional(),
+  productId: z3.string().optional(),
+  entityId: z3.string().optional(),
+  requiredBalance: z3.number().optional(),
+  sendEvent: z3.boolean().optional(),
+  withPreview: z3.boolean().optional(),
+  dialog: z3.any().optional(),
+  entityData: z3.any().optional(),
+  properties: z3.record(z3.string(), z3.any()).optional()
+});
+var TrackParamsSchema = z3.object({
+  featureId: z3.string().optional(),
+  eventName: z3.string().optional(),
+  entityId: z3.string().optional(),
+  value: z3.number().optional(),
+  idempotencyKey: z3.string().optional(),
+  entityData: z3.any().optional()
+});
+var OpenBillingPortalParamsSchema = z3.object({
+  returnUrl: z3.string().optional(),
+  openInNewTab: z3.boolean().optional()
+});
+var SetupPaymentParamsSchema = z3.object({
+  successUrl: z3.string().optional(),
+  checkoutSessionParams: z3.record(z3.string(), z3.any()).optional(),
+  openInNewTab: z3.boolean().optional()
+});
+var QueryParamsSchema = z3.object({
+  featureId: z3.string().or(z3.array(z3.string())),
+  range: QueryRangeEnum.optional()
+});
+
+// src/libraries/react/client/types/clientReferralTypes.ts
+import { z as z4 } from "zod/v4";
+var CreateReferralCodeParamsSchema = z4.object({
+  programId: z4.string()
+});
+var RedeemReferralCodeParamsSchema = z4.object({
+  code: z4.string()
+});
+
+// src/libraries/backend/better-auth.ts
 var router = createRouterWithOptions();
 var betterAuthPathMap = {
   // "create-customer": "customers",
@@ -47,14 +154,13 @@ var betterAuthPathMap = {
 var handleReq = async ({
   ctx,
   options,
-  method,
-  session
+  method
 }) => {
-  let { found, error: resError } = secretKeyCheck();
+  const { found, error: resError } = secretKeyCheck();
   if (!found && !options?.secretKey) {
-    throw new APIError(resError.statusCode, {
-      message: resError.message,
-      code: resError.code
+    throw new APIError(resError?.statusCode ?? "BAD_REQUEST", {
+      message: resError?.message ?? "Unknown error",
+      code: resError?.code ?? "unknown_error"
     });
   }
   const client = new Autumn({
@@ -66,42 +172,75 @@ var handleReq = async ({
     const req = ctx.request;
     const url = new URL(req.url);
     searchParams = Object.fromEntries(url.searchParams);
-  } catch (error) {
+  } catch (_) {
   }
   const rest = ctx.path.split("/autumn/")[1];
   const pathname = `/api/autumn/${betterAuthPathMap[rest] || rest}`;
   const match = findRoute(router, method, pathname);
-  if (!match) {
-    return ctx.json({ error: "Not found" }, { status: 404 });
-  }
-  const { data, params: pathParams } = match;
+  if (!match) return ctx.json({ error: "Not found" }, { status: 404 });
+  const { data } = match;
   const { handler } = data;
   const body = ctx.body;
-  const finalSession = session || ctx.context.session;
-  const identify = async () => {
-    if (!finalSession) {
-      return;
-    }
-    return {
-      customerId: finalSession.user.id,
-      customerData: {
-        email: finalSession.user.email,
-        name: finalSession.user.name
+  const params = ctx.params;
+  let identify;
+  const orgContext = await getOrganizationContext(ctx, options);
+  const finalSession = await getSessionFromCtx(ctx);
+  let identity = null;
+  if (options?.identify) {
+    identity = await getIdentityContext({
+      orgContext,
+      options,
+      session: finalSession
+    });
+  }
+  if (options?.identify) {
+    identify = () => identity;
+  } else {
+    identify = () => {
+      if (!finalSession) return;
+      if (scopeContainsOrg({ options })) {
+        if (orgContext.activeOrganization?.id) {
+          return {
+            customerId: orgContext.activeOrganization?.id,
+            customerData: {
+              email: orgContext.activeOrganizationEmail,
+              name: orgContext.activeOrganization?.name ?? ""
+            }
+          };
+        } else {
+          if (options?.customerScope === "user_and_organization") {
+            return {
+              customerId: finalSession.user.id,
+              customerData: {
+                email: finalSession.user.email,
+                name: finalSession.user.name
+              }
+            };
+          } else return null;
+        }
+      } else {
+        return {
+          customerId: finalSession.user.id,
+          customerData: {
+            email: finalSession.user.email,
+            name: finalSession.user.name
+          }
+        };
       }
     };
-  };
+  }
   const result = await handler({
     autumn: client,
     body,
     path: pathname,
     getCustomer: identify,
-    pathParams,
+    pathParams: params,
     searchParams
   });
   if (result.statusCode >= 400) {
     throw new APIError(result.statusCode, {
-      message: result.body.message,
-      code: result.body.code
+      message: result.body.message ?? "Unknown error",
+      code: result.body.code ?? "unknown_error"
     });
   }
   return ctx.json(result.body, { status: result.statusCode });
@@ -115,18 +254,15 @@ var autumn = (options) => {
         {
           method: "POST",
           use: [],
-          body: z.object({
-            errorOnNotFound: z.boolean().optional(),
-            expand: z.array(CustomerExpandEnum).optional()
+          body: z5.object({
+            errorOnNotFound: z5.boolean().optional(),
+            expand: z5.array(CustomerExpandEnum).optional()
           }),
           metadata: {
             isAction: false
           }
         },
-        async (ctx) => {
-          const session = await getSessionFromCtx(ctx);
-          return await handleReq({ ctx, options, method: "POST", session });
-        }
+        async (ctx) => await handleReq({ ctx, options, method: "POST" })
       ),
       listProducts: createAuthEndpoint(
         "/autumn/products",
@@ -134,89 +270,77 @@ var autumn = (options) => {
           method: "GET",
           use: []
         },
-        async (ctx) => {
-          const session = await getSessionFromCtx(ctx);
-          return await handleReq({ ctx, options, method: "GET", session });
-        }
+        async (ctx) => await handleReq({ ctx, options, method: "GET" })
       ),
       checkout: createAuthEndpoint(
         "/autumn/checkout",
         {
           method: "POST",
-          body: CheckoutParamsSchema.omit({
-            customer_id: true
-          }),
-          use: [sessionMiddleware]
+          use: [],
+          body: CheckoutParamsSchema
         },
-        async (ctx) => handleReq({ ctx, options, method: "POST" })
+        async (ctx) => {
+          console.log("Body: ", ctx.body);
+          return await handleReq({ ctx, options, method: "POST" });
+        }
       ),
       attach: createAuthEndpoint(
         "/autumn/attach",
         {
           method: "POST",
-          body: AttachParamsSchema.omit({
-            customer_id: true
-          }),
-          use: [sessionMiddleware]
+          use: [],
+          body: AttachParamsSchema
         },
-        async (ctx) => handleReq({ ctx, options, method: "POST" })
+        async (ctx) => await handleReq({ ctx, options, method: "POST" })
       ),
       check: createAuthEndpoint(
         "/autumn/check",
         {
           method: "POST",
-          body: CheckParamsSchema.omit({
-            customer_id: true
-          }),
-          use: [sessionMiddleware]
+          use: [],
+          body: CheckParamsSchema
         },
-        async (ctx) => handleReq({ ctx, options, method: "POST" })
+        async (ctx) => {
+          return await handleReq({ ctx, options, method: "POST" });
+        }
       ),
       track: createAuthEndpoint(
         "/autumn/track",
         {
           method: "POST",
-          body: TrackParamsSchema.omit({
-            customer_id: true
-          }),
-          use: [sessionMiddleware]
+          use: [],
+          body: TrackParamsSchema
         },
-        async (ctx) => handleReq({ ctx, options, method: "POST" })
+        async (ctx) => {
+          return await handleReq({ ctx, options, method: "POST" });
+        }
       ),
       cancel: createAuthEndpoint(
         "/autumn/cancel",
         {
           method: "POST",
-          body: CancelParamsSchema.omit({
-            customer_id: true
-          }),
-          use: [sessionMiddleware]
+          use: [],
+          body: CancelParamsSchema
         },
-        async (ctx) => {
-          return await handleReq({ ctx, options, method: "POST" });
-        }
+        async (ctx) => await handleReq({ ctx, options, method: "POST" })
       ),
       createReferralCode: createAuthEndpoint(
-        "/autumn/referrals/create-code",
+        "/autumn/referrals/code",
         {
           method: "POST",
-          body: CreateReferralCodeParamsSchema.omit({
-            customer_id: true
-          }),
-          use: [sessionMiddleware]
+          use: [],
+          body: CreateReferralCodeParamsSchema
         },
         async (ctx) => {
           return await handleReq({ ctx, options, method: "POST" });
         }
       ),
       redeemReferralCode: createAuthEndpoint(
-        "/autumn/referrals/redeem-code",
+        "/autumn/referrals/redeem",
         {
           method: "POST",
-          body: RedeemReferralCodeParamsSchema.omit({
-            customer_id: true
-          }),
-          use: [sessionMiddleware]
+          use: [],
+          body: RedeemReferralCodeParamsSchema
         },
         async (ctx) => {
           return await handleReq({ ctx, options, method: "POST" });
@@ -226,22 +350,48 @@ var autumn = (options) => {
         "/autumn/billing_portal",
         {
           method: "POST",
-          body: BillingPortalParamsSchema,
+          use: [],
+          body: OpenBillingPortalParamsSchema,
           metadata: {
             isAction: false
-          },
-          use: [sessionMiddleware]
+          }
         },
-        async (ctx) => await handleReq({ ctx, options, method: "POST" })
+        async (ctx) => {
+          return await handleReq({ ctx, options, method: "POST" });
+        }
+      ),
+      createEntity: createAuthEndpoint(
+        "/autumn/entities",
+        {
+          method: "POST",
+          use: [],
+          body: CreateEntityParamsSchema
+        },
+        async (ctx) => {
+          return await handleReq({ ctx, options, method: "POST" });
+        }
+      ),
+      getEntity: createAuthEndpoint(
+        "/autumn/entities/:entityId",
+        {
+          method: "GET",
+          use: []
+        },
+        async (ctx) => {
+          return await handleReq({ ctx, options, method: "GET" });
+        }
+      ),
+      deleteEntity: createAuthEndpoint(
+        "/autumn/entities/:entityId",
+        {
+          method: "DELETE",
+          use: []
+        },
+        async (ctx) => await handleReq({ ctx, options, method: "DELETE" })
       )
     }
   };
 };
-var autumnClient = () => ({
-  id: "autumn",
-  $InferServerPlugin: {}
-});
 export {
-  autumn,
-  autumnClient
+  autumn
 };

package/dist/libraries/backend/{chunk-F3S66STP.mjs → chunk-35N7BIAE.mjs}

@@ -1,11 +1,48 @@
 import {
   toBackendError,
   toBackendRes
-} from "./chunk-ENRZQDOT.mjs";
+} from "./chunk-QOJMX7ML.mjs";
 import {
   logger
 } from "./chunk-2TEL6LR5.mjs";
 
+// src/utils/toSnakeCase.ts
+function stringToSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+var toSnakeCase = ({
+  obj,
+  excludeKeys,
+  excludeChildrenOf
+}) => {
+  if (Array.isArray(obj)) {
+    return obj.map(
+      (item) => toSnakeCase({ obj: item, excludeKeys, excludeChildrenOf })
+    );
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => {
+        const snakeKey = stringToSnakeCase(key);
+        if (excludeKeys?.includes(key)) {
+          return [key, value];
+        }
+        if (excludeChildrenOf?.includes(key)) {
+          return [snakeKey, value];
+        }
+        return [
+          snakeKey,
+          toSnakeCase({
+            obj: value,
+            excludeKeys,
+            excludeChildrenOf
+          })
+        ];
+      })
+    );
+  }
+  return obj;
+};
+
 // src/libraries/backend/utils/withAuth.ts
 var withAuth = ({
   fn,
@@ -40,6 +77,12 @@ var withAuth = ({
       }
     }
     let cusData = authResult?.customerData || body?.customer_data;
+    if (body) {
+      body = toSnakeCase({
+        obj: body,
+        excludeChildrenOf: ["checkoutSessionParams", "properties"]
+      });
+    }
     try {
       let res = await fn({
         body,
@@ -62,5 +105,6 @@ var withAuth = ({
 };
 
 export {
+  toSnakeCase,
   withAuth
 };

package/dist/libraries/backend/{chunk-WBHGLFLE.mjs → chunk-4MEEJLXG.mjs}

@@ -1,21 +1,21 @@
 import {
   addGenRoutes
-} from "./chunk-SRHT6RDB.mjs";
+} from "./chunk-PO4EL4BW.mjs";
 import {
   addProductRoutes
-} from "./chunk-7OEFNFGZ.mjs";
+} from "./chunk-MHIUO3ST.mjs";
 import {
   addReferralRoutes
-} from "./chunk-D5C5Q5FZ.mjs";
+} from "./chunk-USQ76FYI.mjs";
 import {
   addEntityRoutes
-} from "./chunk-SVTPC45F.mjs";
+} from "./chunk-LOSIWWM2.mjs";
 import {
   withAuth
-} from "./chunk-F3S66STP.mjs";
+} from "./chunk-35N7BIAE.mjs";
 import {
   fetchPricingTable
-} from "./chunk-ENRZQDOT.mjs";
+} from "./chunk-QOJMX7ML.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";

package/dist/libraries/backend/{chunk-SVTPC45F.mjs → chunk-LOSIWWM2.mjs}

@@ -1,6 +1,6 @@
 import {
   withAuth
-} from "./chunk-F3S66STP.mjs";
+} from "./chunk-35N7BIAE.mjs";
 
 // src/libraries/backend/routes/entityRoutes.ts
 import { addRoute } from "rou3";

package/dist/libraries/backend/{chunk-7OEFNFGZ.mjs → chunk-MHIUO3ST.mjs}

@@ -1,6 +1,6 @@
 import {
   withAuth
-} from "./chunk-F3S66STP.mjs";
+} from "./chunk-35N7BIAE.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";

package/dist/libraries/backend/{chunk-SRHT6RDB.mjs → chunk-PO4EL4BW.mjs}

@@ -1,37 +1,14 @@
 import {
   withAuth
-} from "./chunk-F3S66STP.mjs";
+} from "./chunk-35N7BIAE.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";
 
 // src/libraries/backend/routes/genRoutes.ts
 import { addRoute } from "rou3";
-
-// src/libraries/react/utils/toSnakeCase.ts
-function stringToSnakeCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
-}
-var toSnakeCase = (obj, excludeKeys) => {
-  if (Array.isArray(obj)) {
-    return obj.map((item) => toSnakeCase(item, excludeKeys));
-  } else if (obj !== null && typeof obj === "object") {
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => {
-        const snakeKey = stringToSnakeCase(key);
-        if (excludeKeys && excludeKeys.includes(key)) {
-          return [snakeKey, value];
-        }
-        return [snakeKey, toSnakeCase(value, excludeKeys)];
-      })
-    );
-  }
-  return obj;
-};
-
-// src/libraries/backend/routes/genRoutes.ts
 var sanitizeBody = (body) => {
-  let bodyCopy = { ...body };
+  const bodyCopy = { ...body };
   delete bodyCopy.customer_id;
   delete bodyCopy.customer_data;
   return bodyCopy;
@@ -43,11 +20,12 @@ var checkoutHandler = withAuth({
     customer_data,
     body
   }) => {
-    return await autumn.checkout({
+    const result = await autumn.checkout({
       ...sanitizeBody(body),
       customer_id,
       customer_data
     });
+    return result;
   }
 });
 var attachHandler = withAuth({
@@ -134,7 +112,11 @@ var queryHandler = withAuth({
     customer_id,
     body
   }) => {
-    return await autumn.query({ customer_id, ...toSnakeCase(body) });
+    return await autumn.query({
+      customer_id,
+      range: body.range,
+      feature_id: body.featureId
+    });
   }
 });
 var addGenRoutes = (router) => {