autumn-js 0.1.21 → 0.1.23

package/dist/libraries/backend/convex.js

@@ -1,1448 +1 @@
 "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/libraries/backend/convex.ts
-var convex_exports = {};
-__export(convex_exports, {
-  autumnHandler: () => autumnHandler
-});
-module.exports = __toCommonJS(convex_exports);
-
-// src/sdk/error.ts
-var AutumnError = class _AutumnError extends Error {
-  message;
-  code;
-  constructor(response) {
-    super(response.message);
-    this.message = response.message;
-    this.code = response.code;
-  }
-  static fromError(error) {
-    return new _AutumnError({
-      message: error.message || "Unknown error",
-      code: error.code || "unknown_error"
-    });
-  }
-  toString() {
-    return `${this.message} (code: ${this.code})`;
-  }
-  toJSON() {
-    return {
-      message: this.message,
-      code: this.code
-    };
-  }
-};
-
-// src/sdk/general/genMethods.ts
-var handleCheckout = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/checkout", params);
-};
-var handleAttach = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/attach", params);
-};
-var handleSetupPayment = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/setup_payment", params);
-};
-var handleCancel = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/cancel", params);
-};
-var handleTrack = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/track", params);
-};
-var handleUsage = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/usage", params);
-};
-var handleCheck = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/check", params);
-};
-var handleQuery = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/query", params);
-};
-
-// src/libraries/backend/constants.ts
-var autumnApiUrl = "https://api.useautumn.com/v1";
-var BASE_PATH = "/api/autumn";
-
-// src/sdk/utils.ts
-var staticWrapper = (callback, instance, args) => {
-  if (!instance) {
-    instance = new Autumn();
-  }
-  return callback({ instance, ...args });
-};
-
-// src/sdk/customers/cusMethods.ts
-var customerMethods = (instance) => {
-  return {
-    get: (id, params) => staticWrapper(getCustomer, instance, { id, params }),
-    create: (params) => staticWrapper(createCustomer, instance, { params }),
-    update: (id, params) => staticWrapper(updateCustomer, instance, { id, params }),
-    delete: (id) => staticWrapper(deleteCustomer, instance, { id }),
-    billingPortal: (id, params) => staticWrapper(billingPortal, instance, { id, params }),
-    updateBalances: (id, params) => staticWrapper(updateBalances, instance, { id, params })
-  };
-};
-var getExpandStr = (expand) => {
-  if (!expand) {
-    return "";
-  }
-  return `expand=${expand.join(",")}`;
-};
-var getCustomer = async ({
-  instance,
-  id,
-  params
-}) => {
-  if (!id) {
-    return {
-      data: null,
-      error: new AutumnError({
-        message: "Customer ID is required",
-        code: "CUSTOMER_ID_REQUIRED"
-      })
-    };
-  }
-  return instance.get(`/customers/${id}?${getExpandStr(params?.expand)}`);
-};
-var createCustomer = async ({
-  instance,
-  params
-}) => {
-  return instance.post(`/customers?${getExpandStr(params?.expand)}`, params);
-};
-var updateCustomer = async ({
-  instance,
-  id,
-  params
-}) => {
-  return instance.post(`/customers/${id}`, params);
-};
-var deleteCustomer = async ({
-  instance,
-  id
-}) => {
-  return instance.delete(`/customers/${id}`);
-};
-var billingPortal = async ({
-  instance,
-  id,
-  params
-}) => {
-  return instance.post(`/customers/${id}/billing_portal`, params);
-};
-var updateBalances = async ({
-  instance,
-  id,
-  params
-}) => {
-  return instance.post(`/customers/${id}/balances`, {
-    balances: Array.isArray(params) ? params : [params]
-  });
-};
-
-// src/sdk/customers/entities/entMethods.ts
-var entityMethods = (instance) => {
-  return {
-    get: (customer_id, entity_id, params) => staticWrapper(getEntity, instance, {
-      customer_id,
-      entity_id,
-      params
-    }),
-    create: (customer_id, params) => staticWrapper(createEntity, instance, { customer_id, params }),
-    transfer: (customer_id, params) => staticWrapper(transferProduct, instance, { customer_id, params }),
-    delete: (customer_id, entity_id) => staticWrapper(deleteEntity, instance, { customer_id, entity_id })
-  };
-};
-var getExpandStr2 = (expand) => {
-  if (!expand) {
-    return "";
-  }
-  return `expand=${expand.join(",")}`;
-};
-var getEntity = async ({
-  instance,
-  customer_id,
-  entity_id,
-  params
-}) => {
-  return instance.get(
-    `/customers/${customer_id}/entities/${entity_id}?${getExpandStr2(
-      params?.expand
-    )}`
-  );
-};
-var createEntity = async ({
-  instance,
-  customer_id,
-  params
-}) => {
-  return instance.post(`/customers/${customer_id}/entities`, params);
-};
-var deleteEntity = async ({
-  instance,
-  customer_id,
-  entity_id
-}) => {
-  return instance.delete(`/customers/${customer_id}/entities/${entity_id}`);
-};
-var transferProduct = async ({
-  instance,
-  customer_id,
-  params
-}) => {
-  return instance.post(`/customers/${customer_id}/transfer`, params);
-};
-
-// src/sdk/products/prodMethods.ts
-var productMethods = (instance) => {
-  return {
-    get: (id) => staticWrapper(getProduct, instance, { id }),
-    create: (params) => staticWrapper(createProduct, instance, { params }),
-    list: (params) => staticWrapper(listProducts, instance, { params })
-  };
-};
-var listProducts = async ({
-  instance,
-  params
-}) => {
-  let path = "/products_beta";
-  if (params) {
-    const queryParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (value !== void 0) {
-        queryParams.append(key, String(value));
-      }
-    }
-    const queryString = queryParams.toString();
-    if (queryString) {
-      path += `?${queryString}`;
-    }
-  }
-  return instance.get(path);
-};
-var getProduct = async ({
-  instance,
-  id
-}) => {
-  return instance.get(`/products/${id}`);
-};
-var createProduct = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/products", params);
-};
-
-// src/sdk/referrals/referralMethods.ts
-var referralMethods = (instance) => {
-  return {
-    createCode: (params) => staticWrapper(createReferralCode, instance, { params }),
-    redeemCode: (params) => staticWrapper(redeemReferralCode, instance, { params })
-  };
-};
-var createReferralCode = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/referrals/code", params);
-};
-var redeemReferralCode = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/referrals/redeem", params);
-};
-
-// src/sdk/response.ts
-var toContainerResult = async ({
-  response,
-  logger: logger2,
-  logError = true
-}) => {
-  if (response.status < 200 || response.status >= 300) {
-    let error;
-    try {
-      error = await response.json();
-      if (logError) {
-        logger2.error(`[Autumn] ${error.message}`);
-      }
-    } catch (error2) {
-      throw error2;
-      return {
-        data: null,
-        error: new AutumnError({
-          message: "Failed to parse JSON response from Autumn",
-          code: "internal_error"
-        }),
-        statusCode: response.status
-      };
-    }
-    return {
-      data: null,
-      error: new AutumnError({
-        message: error.message,
-        code: error.code
-      }),
-      statusCode: response.status
-    };
-  }
-  try {
-    let data = await response.json();
-    return {
-      data,
-      error: null,
-      statusCode: response?.status
-    };
-  } catch (error) {
-    throw error;
-    return {
-      data: null,
-      error: new AutumnError({
-        message: "Failed to parse Autumn API response",
-        code: "internal_error"
-      }),
-      statusCode: response?.status
-    };
-  }
-};
-
-// src/utils/logger.ts
-var getTime = () => {
-  let timeString = (/* @__PURE__ */ new Date()).toISOString();
-  return `[${timeString.split("T")[1].split(".")[0]}]`;
-};
-var greaterThanLevel = (level) => {
-  return levels.indexOf(level) >= levels.indexOf(logger.level);
-};
-var levels = ["debug", "info", "warn", "error", "fatal"];
-var logger = {
-  ...console,
-  level: "info",
-  debug: (...args) => {
-    if (greaterThanLevel("debug")) {
-      console.log(getTime(), "DEBUG", ...args);
-    }
-  },
-  log: (...args) => {
-    console.log(getTime(), "INFO", ...args);
-  },
-  info: (...args) => {
-    if (greaterThanLevel("info")) {
-      console.log(getTime(), "INFO", ...args);
-    }
-  },
-  warn: (...args) => {
-    if (greaterThanLevel("warn")) {
-      console.log(getTime(), "WARN", ...args);
-    }
-  },
-  error: (...args) => {
-    if (greaterThanLevel("error")) {
-      console.log(getTime(), "ERROR", ...args);
-    }
-  }
-};
-
-// src/sdk/features/featureMethods.ts
-var featureMethods = (instance) => {
-  return {
-    list: () => staticWrapper(listFeatures, instance, {})
-  };
-};
-var listFeatures = async ({
-  instance,
-  params
-}) => {
-  let path = "/features";
-  if (params) {
-    const queryParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (value !== void 0) {
-        queryParams.append(key, String(value));
-      }
-    }
-    const queryString = queryParams.toString();
-    if (queryString) {
-      path += `?${queryString}`;
-    }
-  }
-  return instance.get(path);
-};
-
-// src/sdk/client.ts
-var LATEST_API_VERSION = "1.2";
-var Autumn = class {
-  secretKey;
-  publishableKey;
-  headers;
-  url;
-  logger = console;
-  constructor(options) {
-    try {
-      this.secretKey = options?.secretKey || process.env.AUTUMN_SECRET_KEY;
-      this.publishableKey = options?.publishableKey || process.env.AUTUMN_PUBLISHABLE_KEY;
-    } catch (error) {
-    }
-    if (!this.secretKey && !this.publishableKey && !options?.headers) {
-      throw new Error("Autumn secret key or publishable key is required");
-    }
-    this.headers = options?.headers || {
-      Authorization: `Bearer ${this.secretKey || this.publishableKey}`,
-      "Content-Type": "application/json"
-    };
-    let version = options?.version || LATEST_API_VERSION;
-    this.headers["x-api-version"] = version;
-    this.url = options?.url || autumnApiUrl;
-    this.logger = logger;
-    this.logger.level = options?.logLevel || "info";
-  }
-  async get(path) {
-    const response = await fetch(`${this.url}${path}`, {
-      headers: this.headers
-    });
-    return toContainerResult({ response, logger: this.logger });
-  }
-  async post(path, body) {
-    try {
-      const response = await fetch(`${this.url}${path}`, {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify(body)
-      });
-      return toContainerResult({ response, logger: this.logger });
-    } catch (error) {
-      console.error("Error sending request:", error);
-      throw error;
-    }
-  }
-  async delete(path) {
-    const response = await fetch(`${this.url}${path}`, {
-      method: "DELETE",
-      headers: this.headers
-    });
-    return toContainerResult({ response, logger: this.logger });
-  }
-  static customers = customerMethods();
-  static products = productMethods();
-  static entities = entityMethods();
-  static referrals = referralMethods();
-  static features = featureMethods();
-  customers = customerMethods(this);
-  products = productMethods(this);
-  entities = entityMethods(this);
-  referrals = referralMethods(this);
-  features = featureMethods(this);
-  /**
-   * Initiates a checkout flow for a product purchase.
-   * 
-   * The checkout function handles the purchase process for products with pricing.
-   * It determines whether to show a dialog for user input or redirect directly
-   * to Stripe based on the customer's state and product requirements.
-   * 
-   * @param params - Checkout parameters including product ID, customer data, and options
-   * @returns Promise resolving to checkout details including pricing, prorations, and URLs
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.checkout({
-   *   customer_id: "user_123",
-   *   product_id: "pro",
-   *   success_url: "https://myapp.com/success"
-   * });
-   * 
-   * if (result.url) {
-   *   // Redirect to Stripe checkout
-   *   window.location.href = result.url;
-   * }
-   * ```
-   */
-  async checkout(params) {
-    return handleCheckout({
-      instance: this,
-      params
-    });
-  }
-  static checkout = (params) => staticWrapper(handleCheckout, void 0, { params });
-  static usage = (params) => staticWrapper(handleUsage, void 0, { params });
-  /**
-   * Attaches a product to a customer, enabling access and handling billing.
-   * 
-   * The attach function activates a product for a customer and applies all product items.
-   * When you attach a product:
-   * - The customer gains access to all features in the product
-   * - If the product has prices, the customer will be billed accordingly  
-   * - If there's no existing payment method, a checkout URL will be generated
-   * 
-   * @param params - Attach parameters including customer ID, product ID, and options
-   * @returns Promise resolving to attachment result with checkout URL if needed
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.attach({
-   *   customer_id: "user_123",
-   *   product_id: "pro",
-   *   success_url: "https://myapp.com/success"
-   * });
-   * 
-   * if (result.checkout_url) {
-   *   // Payment required - redirect to checkout
-   *   window.location.href = result.checkout_url;
-   * } else {
-   *   // Product successfully attached
-   *   console.log("Access granted:", result.message);
-   * }
-   * ```
-   */
-  async attach(params) {
-    return handleAttach({
-      instance: this,
-      params
-    });
-  }
-  static attach = (params) => staticWrapper(handleAttach, void 0, { params });
-  static setupPayment = (params) => staticWrapper(handleSetupPayment, void 0, { params });
-  /**
-   * Sets up a payment method for a customer.
-   * 
-   * This method allows you to set up payment methods for customers without 
-   * immediately charging them. Useful for collecting payment information
-   * before product attachment or for updating existing payment methods.
-   * 
-   * @param params - Setup payment parameters including customer information
-   * @returns Promise resolving to setup payment result
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.setupPayment({
-   *   customer_id: "user_123"
-   * });
-   * ```
-   */
-  async setupPayment(params) {
-    return handleSetupPayment({
-      instance: this,
-      params
-    });
-  }
-  static cancel = (params) => staticWrapper(handleCancel, void 0, { params });
-  /**
-   * Cancels a customer's subscription or product attachment.
-   * 
-   * This method allows you to cancel a customer's subscription to a specific product.
-   * You can choose to cancel immediately or at the end of the billing cycle.
-   * 
-   * @param params - Cancel parameters including customer ID and product ID
-   * @returns Promise resolving to cancellation result
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.cancel({
-   *   customer_id: "user_123",
-   *   product_id: "pro",
-   *   cancel_immediately: false // Cancel at end of billing cycle
-   * });
-   * ```
-   */
-  async cancel(params) {
-    return handleCancel({
-      instance: this,
-      params
-    });
-  }
-  static check = (params) => staticWrapper(handleCheck, void 0, { params });
-  /**
-   * Checks if a customer has access to a specific feature.
-   * 
-   * This method verifies whether a customer has permission to use a feature
-   * and checks their remaining balance/usage limits. It can be used to gate
-   * features and determine when to show upgrade prompts.
-   * 
-   * @param params - Check parameters including customer ID and feature ID
-   * @returns Promise resolving to access check result with allowed status and balance info
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.check({
-   *   customer_id: "user_123",
-   *   feature_id: "messages",
-   *   required_balance: 1
-   * });
-   * 
-   * if (!result.allowed) {
-   *   console.log("Feature access denied - upgrade required");
-   * }
-   * ```
-   */
-  async check(params) {
-    return handleCheck({
-      instance: this,
-      params
-    });
-  }
-  static track = (params) => staticWrapper(handleTrack, void 0, { params });
-  /**
-   * Tracks usage events for features or analytics.
-   * 
-   * This method records usage events for metered features, updating the customer's
-   * balance and usage statistics. It's typically used server-side to ensure
-   * accurate tracking that cannot be manipulated by users.
-   * 
-   * @param params - Track parameters including customer ID, feature ID, and usage value
-   * @returns Promise resolving to tracking result
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.track({
-   *   customer_id: "user_123",
-   *   feature_id: "messages",
-   *   value: 1 // Track 1 message sent
-   * });
-   * ```
-   */
-  async track(params) {
-    return handleTrack({
-      instance: this,
-      params
-    });
-  }
-  /**
-   * Retrieves usage statistics and analytics for a customer.
-   * 
-   * This method fetches detailed usage information for a customer's features,
-   * including current balances, usage history, and analytics data. Useful
-   * for displaying usage dashboards or generating reports.
-   * 
-   * @param params - Usage parameters including customer ID and optional filters
-   * @returns Promise resolving to usage statistics and analytics data
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.usage({
-   *   customer_id: "user_123",
-   *   feature_id: "messages" 
-   *   value: 20 // Usage value
-   * });
-   * ```
-   */
-  async usage(params) {
-    return handleUsage({
-      instance: this,
-      params
-    });
-  }
-  static query = (params) => staticWrapper(handleQuery, void 0, { params });
-  /**
-   * Performs advanced queries on customer data and analytics.
-   * 
-   * This method allows you to run complex queries against customer data,
-   * usage patterns, and billing information. Useful for generating reports,
-   * analytics, and custom data insights.
-   * 
-   * @param params - Query parameters including customer ID and query specifications
-   * @returns Promise resolving to query results with requested data
-   * 
-   * @example
-   * ```typescript
-   * const result = await autumn.query({
-   *   customer_id: "user_123",
-   *   feature_id: "messages" // feature id to fetch for query, can also be an array
-   * });
-   * 
-   * ```
-   */
-  async query(params) {
-    return handleQuery({
-      instance: this,
-      params
-    });
-  }
-};
-
-// src/sdk/products/prodEnums.ts
-var ProductItemInterval = /* @__PURE__ */ ((ProductItemInterval2) => {
-  ProductItemInterval2["Minute"] = "minute";
-  ProductItemInterval2["Hour"] = "hour";
-  ProductItemInterval2["Day"] = "day";
-  ProductItemInterval2["Week"] = "week";
-  ProductItemInterval2["Month"] = "month";
-  ProductItemInterval2["Quarter"] = "quarter";
-  ProductItemInterval2["SemiAnnual"] = "semi_annual";
-  ProductItemInterval2["Year"] = "year";
-  ProductItemInterval2["Multiple"] = "multiple";
-  return ProductItemInterval2;
-})(ProductItemInterval || {});
-
-// src/sdk/customers/cusEnums.ts
-var import_v4 = require("zod/v4");
-var CustomerExpandEnum = import_v4.z.enum([
-  "invoices",
-  "rewards",
-  "trials_used",
-  "entities",
-  "referrals",
-  "payment_method"
-]);
-
-// src/sdk/customers/cusTypes.ts
-var import_v42 = require("zod/v4");
-var CoreCusFeatureSchema = import_v42.z.object({
-  unlimited: import_v42.z.boolean().optional(),
-  interval: import_v42.z.enum(ProductItemInterval).optional(),
-  balance: import_v42.z.number().nullish(),
-  usage: import_v42.z.number().optional(),
-  included_usage: import_v42.z.number().optional(),
-  next_reset_at: import_v42.z.number().nullish(),
-  overage_allowed: import_v42.z.boolean().optional(),
-  usage_limit: import_v42.z.number().optional(),
-  rollovers: import_v42.z.object({
-    balance: import_v42.z.number(),
-    expires_at: import_v42.z.number()
-  }).optional(),
-  breakdown: import_v42.z.array(
-    import_v42.z.object({
-      interval: import_v42.z.enum(ProductItemInterval),
-      balance: import_v42.z.number().optional(),
-      usage: import_v42.z.number().optional(),
-      included_usage: import_v42.z.number().optional(),
-      next_reset_at: import_v42.z.number().optional()
-    })
-  ).optional(),
-  credit_schema: import_v42.z.array(
-    import_v42.z.object({
-      feature_id: import_v42.z.string(),
-      credit_amount: import_v42.z.number()
-    })
-  ).optional()
-});
-var CustomerDataSchema = import_v42.z.object({
-  name: import_v42.z.string().nullish(),
-  email: import_v42.z.string().nullish(),
-  fingerprint: import_v42.z.string().nullish()
-});
-var CreateCustomerParamsSchema = import_v42.z.object({
-  id: import_v42.z.string().nullish(),
-  email: import_v42.z.string().nullish(),
-  name: import_v42.z.string().nullish(),
-  fingerprint: import_v42.z.string().nullish(),
-  metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional(),
-  expand: import_v42.z.array(CustomerExpandEnum).optional(),
-  stripe_id: import_v42.z.string().nullish()
-});
-var BillingPortalParamsSchema = import_v42.z.object({
-  return_url: import_v42.z.string().optional()
-});
-var UpdateBalancesParamsSchema = import_v42.z.object({
-  feature_id: import_v42.z.string(),
-  balance: import_v42.z.number()
-}).or(
-  import_v42.z.array(
-    import_v42.z.object({
-      feature_id: import_v42.z.string(),
-      balance: import_v42.z.number()
-    })
-  )
-);
-
-// src/sdk/general/checkTypes.ts
-var import_v43 = require("zod/v4");
-var CheckFeatureResultSchema = import_v43.z.object({
-  allowed: import_v43.z.boolean(),
-  feature_id: import_v43.z.string(),
-  customer_id: import_v43.z.string(),
-  entity_id: import_v43.z.string().optional(),
-  required_balance: import_v43.z.number()
-}).extend(CoreCusFeatureSchema.shape);
-
-// src/sdk/customers/entities/entTypes.ts
-var import_v44 = require("zod/v4");
-var EntityDataSchema = import_v44.z.object({
-  name: import_v44.z.string().optional(),
-  feature_id: import_v44.z.string()
-});
-var TransferProductParamsSchema = import_v44.z.object({
-  from_entity_id: import_v44.z.string(),
-  to_entity_id: import_v44.z.string(),
-  product_id: import_v44.z.string()
-});
-
-// src/sdk/general/genTypes.ts
-var import_v45 = require("zod/v4");
-var CancelParamsSchema = import_v45.z.object({
-  customer_id: import_v45.z.string(),
-  product_id: import_v45.z.string(),
-  entity_id: import_v45.z.string().optional(),
-  cancel_immediately: import_v45.z.boolean().optional()
-});
-var CancelResultSchema = import_v45.z.object({
-  success: import_v45.z.boolean(),
-  customer_id: import_v45.z.string(),
-  product_id: import_v45.z.string()
-});
-var TrackParamsSchema = import_v45.z.object({
-  customer_id: import_v45.z.string(),
-  value: import_v45.z.number().optional(),
-  feature_id: import_v45.z.string().optional(),
-  event_name: import_v45.z.string().optional(),
-  entity_id: import_v45.z.string().optional(),
-  customer_data: import_v45.z.any().optional(),
-  idempotency_key: import_v45.z.string().optional(),
-  entity_data: import_v45.z.any().optional()
-});
-var TrackResultSchema = import_v45.z.object({
-  id: import_v45.z.string(),
-  code: import_v45.z.string(),
-  customer_id: import_v45.z.string(),
-  feature_id: import_v45.z.string().optional(),
-  event_name: import_v45.z.string().optional()
-});
-var CheckParamsSchema = import_v45.z.object({
-  customer_id: import_v45.z.string(),
-  feature_id: import_v45.z.string().optional(),
-  product_id: import_v45.z.string().optional(),
-  entity_id: import_v45.z.string().optional(),
-  customer_data: import_v45.z.any().optional(),
-  required_balance: import_v45.z.number().optional(),
-  send_event: import_v45.z.boolean().optional(),
-  with_preview: import_v45.z.boolean().optional(),
-  entity_data: EntityDataSchema.optional()
-});
-var QueryRangeEnum = import_v45.z.enum(["24h", "7d", "30d", "90d", "last_cycle"]);
-var QueryParamsSchema = import_v45.z.object({
-  customer_id: import_v45.z.string(),
-  feature_id: import_v45.z.string().or(import_v45.z.array(import_v45.z.string())),
-  range: QueryRangeEnum.optional()
-});
-
-// src/sdk/components/componentMethods.ts
-var fetchPricingTable = async ({
-  instance,
-  params
-}) => {
-  let path = "/components/pricing_table";
-  if (params) {
-    const queryParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (key === "products") {
-        continue;
-      }
-      if (value !== void 0) {
-        queryParams.append(key, String(value));
-      }
-    }
-    const queryString = queryParams.toString();
-    if (queryString) {
-      path += `?${queryString}`;
-    }
-  }
-  return await instance.get(path);
-};
-
-// src/sdk/referrals/referralTypes.ts
-var import_v46 = require("zod/v4");
-var CreateReferralCodeParamsSchema = import_v46.z.object({
-  customer_id: import_v46.z.string(),
-  program_id: import_v46.z.string()
-});
-var RedeemReferralCodeParamsSchema = import_v46.z.object({
-  code: import_v46.z.string(),
-  customer_id: import_v46.z.string()
-});
-
-// src/sdk/general/attachTypes.ts
-var import_v47 = require("zod/v4");
-var AttachFeatureOptionsSchema = import_v47.z.object({
-  feature_id: import_v47.z.string(),
-  quantity: import_v47.z.number()
-});
-var AttachParamsSchema = import_v47.z.object({
-  customer_id: import_v47.z.string(),
-  product_id: import_v47.z.string().optional(),
-  entity_id: import_v47.z.string().optional(),
-  options: import_v47.z.array(AttachFeatureOptionsSchema).optional(),
-  product_ids: import_v47.z.array(import_v47.z.string()).optional(),
-  free_trial: import_v47.z.boolean().optional(),
-  success_url: import_v47.z.string().optional(),
-  metadata: import_v47.z.record(import_v47.z.string(), import_v47.z.string()).optional(),
-  force_checkout: import_v47.z.boolean().optional(),
-  customer_data: CustomerDataSchema.optional(),
-  entity_data: import_v47.z.any().optional(),
-  checkout_session_params: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional(),
-  reward: import_v47.z.string().optional(),
-  invoice: import_v47.z.boolean().optional()
-});
-var AttachResultSchema = import_v47.z.object({
-  checkout_url: import_v47.z.string().optional(),
-  customer_id: import_v47.z.string(),
-  product_ids: import_v47.z.array(import_v47.z.string()),
-  code: import_v47.z.string(),
-  message: import_v47.z.string(),
-  customer_data: import_v47.z.any().optional(),
-  invoice: import_v47.z.object({
-    status: import_v47.z.string(),
-    stripe_id: import_v47.z.string(),
-    hosted_invoice_url: import_v47.z.string().nullable(),
-    total: import_v47.z.number(),
-    currency: import_v47.z.string()
-  }).optional()
-});
-var CheckoutParamsSchema = import_v47.z.object({
-  customer_id: import_v47.z.string(),
-  product_id: import_v47.z.string(),
-  product_ids: import_v47.z.array(import_v47.z.string()).optional(),
-  entity_id: import_v47.z.string().optional(),
-  options: import_v47.z.array(AttachFeatureOptionsSchema).optional(),
-  force_checkout: import_v47.z.boolean().optional(),
-  invoice: import_v47.z.boolean().optional(),
-  success_url: import_v47.z.string().optional(),
-  customer_data: CustomerDataSchema.optional(),
-  entity_data: import_v47.z.any().optional(),
-  checkout_session_params: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional(),
-  reward: import_v47.z.string().optional()
-});
-
-// src/libraries/backend/utils/backendRes.ts
-var toBackendRes = ({ res }) => {
-  let statusCode = res.statusCode ? res.statusCode : res.error ? 500 : 200;
-  return {
-    body: res.data ? res.data : res.error,
-    statusCode
-  };
-};
-var toBackendError = ({
-  path,
-  message,
-  code,
-  statusCode = 500
-}) => {
-  return {
-    statusCode,
-    body: new AutumnError({
-      message: message || "Internal server error",
-      code: code || "internal_server_error"
-    })
-  };
-};
-
-// src/libraries/backend/utils/withAuth.ts
-var withAuth = ({
-  fn,
-  requireCustomer = true
-}) => {
-  return async ({
-    autumn,
-    body,
-    path,
-    getCustomer: getCustomer2,
-    pathParams,
-    searchParams
-  }) => {
-    let authResult = await getCustomer2();
-    let customerId = authResult?.customerId;
-    if (!customerId && requireCustomer) {
-      if (body?.errorOnNotFound === false) {
-        return {
-          statusCode: 202,
-          body: null
-        };
-      } else {
-        logger.error(
-          `[Autumn]: customerId returned from identify function is ${customerId}`
-        );
-        return toBackendError({
-          path,
-          message: `customerId returned from identify function is ${customerId}`,
-          code: "no_customer_id",
-          statusCode: 401
-        });
-      }
-    }
-    let cusData = authResult?.customerData || body?.customer_data;
-    try {
-      let res = await fn({
-        body,
-        autumn,
-        customer_id: customerId,
-        customer_data: cusData,
-        pathParams,
-        searchParams
-      });
-      return toBackendRes({ res });
-    } catch (error) {
-      logger.error(`${error.message}`);
-      return toBackendError({
-        path,
-        message: error.message || "unknown error",
-        code: "internal_error"
-      });
-    }
-  };
-};
-
-// src/libraries/backend/routes/genRoutes.ts
-var import_rou3 = require("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 };
-  delete bodyCopy.customer_id;
-  delete bodyCopy.customer_data;
-  return bodyCopy;
-};
-var checkoutHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    customer_data,
-    body
-  }) => {
-    return await autumn.checkout({
-      ...sanitizeBody(body),
-      customer_id,
-      customer_data
-    });
-  }
-});
-var attachHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    customer_data,
-    body
-  }) => {
-    return await autumn.attach({
-      ...sanitizeBody(body),
-      customer_id,
-      customer_data
-    });
-  }
-});
-var setupPaymentHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    customer_data,
-    body
-  }) => {
-    return await autumn.setupPayment({
-      ...sanitizeBody(body),
-      customer_id,
-      customer_data
-    });
-  }
-});
-var cancelHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    body
-  }) => {
-    return await autumn.cancel({
-      ...sanitizeBody(body),
-      customer_id
-    });
-  }
-});
-var checkHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    customer_data,
-    body
-  }) => {
-    const result = await autumn.check({
-      ...sanitizeBody(body),
-      customer_id,
-      customer_data
-    });
-    return result;
-  }
-});
-var trackHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    customer_data,
-    body
-  }) => {
-    return await autumn.track({
-      ...sanitizeBody(body),
-      customer_id,
-      customer_data
-    });
-  }
-});
-var openBillingPortalHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    body
-  }) => {
-    return await autumn.customers.billingPortal(customer_id, body);
-  }
-});
-var queryHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    body
-  }) => {
-    return await autumn.query({ customer_id, ...toSnakeCase(body) });
-  }
-});
-var addGenRoutes = (router) => {
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/checkout`, {
-    handler: checkoutHandler
-  });
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/attach`, {
-    handler: attachHandler
-  });
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/cancel`, {
-    handler: cancelHandler
-  });
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/check`, {
-    handler: checkHandler
-  });
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/track`, {
-    handler: trackHandler
-  });
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/billing_portal`, {
-    handler: openBillingPortalHandler
-  });
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/setup_payment`, {
-    handler: setupPaymentHandler
-  });
-  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/query`, {
-    handler: queryHandler
-  });
-};
-
-// src/libraries/backend/routes/backendRouter.ts
-var import_rou35 = require("rou3");
-
-// src/libraries/backend/routes/entityRoutes.ts
-var import_rou32 = require("rou3");
-var createEntityHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    body
-  }) => {
-    return await autumn.entities.create(customer_id, body);
-  }
-});
-var getEntityHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    pathParams,
-    searchParams
-  }) => {
-    if (!pathParams?.entityId) {
-      return {
-        statusCode: 400,
-        body: {
-          error: "no_entity_id",
-          message: "Entity ID is required"
-        }
-      };
-    }
-    let params = {
-      expand: searchParams?.expand?.split(",")
-    };
-    let res = await autumn.entities.get(
-      customer_id,
-      pathParams.entityId,
-      params
-    );
-    return res;
-  }
-});
-var deleteEntityHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    pathParams
-  }) => {
-    if (!pathParams?.entityId) {
-      return {
-        statusCode: 400,
-        body: {
-          error: "no_entity_id",
-          message: "Entity ID is required"
-        }
-      };
-    }
-    return await autumn.entities.delete(customer_id, pathParams.entityId);
-  }
-});
-var addEntityRoutes = async (router) => {
-  (0, import_rou32.addRoute)(router, "POST", "/api/autumn/entities", {
-    handler: createEntityHandler
-  });
-  (0, import_rou32.addRoute)(router, "GET", "/api/autumn/entities/:entityId", {
-    handler: getEntityHandler
-  });
-  (0, import_rou32.addRoute)(router, "DELETE", "/api/autumn/entities/:entityId", {
-    handler: deleteEntityHandler
-  });
-};
-
-// src/libraries/backend/routes/referralRoutes.ts
-var import_rou33 = require("rou3");
-var createReferralCodeHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    body
-  }) => {
-    return await autumn.referrals.createCode({
-      ...body,
-      customer_id
-    });
-  }
-});
-var redeemReferralCodeHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    body
-  }) => {
-    return await autumn.referrals.redeemCode({
-      ...body,
-      customer_id
-    });
-  }
-});
-var addReferralRoutes = async (router) => {
-  (0, import_rou33.addRoute)(router, "POST", `${BASE_PATH}/referrals/code`, {
-    handler: createReferralCodeHandler
-  });
-  (0, import_rou33.addRoute)(router, "POST", `${BASE_PATH}/referrals/redeem`, {
-    handler: redeemReferralCodeHandler
-  });
-};
-
-// src/libraries/backend/routes/productRoutes.ts
-var import_rou34 = require("rou3");
-var listProductsHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id
-  }) => {
-    return await autumn.products.list({
-      customer_id
-    });
-  },
-  requireCustomer: false
-});
-var addProductRoutes = async (router) => {
-  (0, import_rou34.addRoute)(router, "GET", `${BASE_PATH}/products`, {
-    handler: listProductsHandler
-  });
-};
-
-// src/libraries/backend/routes/backendRouter.ts
-var sanitizeCustomerBody = (body) => {
-  let bodyCopy = { ...body };
-  delete bodyCopy.id;
-  delete bodyCopy.name;
-  delete bodyCopy.email;
-  return bodyCopy;
-};
-var createCustomerHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id,
-    customer_data = {},
-    body
-  }) => {
-    let res = await autumn.customers.create({
-      id: customer_id,
-      ...customer_data,
-      ...sanitizeCustomerBody(body)
-    });
-    return res;
-  }
-});
-var getPricingTableHandler = withAuth({
-  fn: async ({
-    autumn,
-    customer_id
-  }) => {
-    return await fetchPricingTable({
-      instance: autumn,
-      params: {
-        customer_id: customer_id || void 0
-      }
-    });
-  },
-  requireCustomer: false
-});
-var createRouterWithOptions = () => {
-  const router = (0, import_rou35.createRouter)();
-  (0, import_rou35.addRoute)(router, "POST", `${BASE_PATH}/cors`, {
-    handler: () => {
-      return {
-        body: {
-          message: "OK"
-        },
-        statusCode: 200
-      };
-    }
-  });
-  (0, import_rou35.addRoute)(router, "POST", `${BASE_PATH}/customers`, {
-    handler: createCustomerHandler
-  });
-  (0, import_rou35.addRoute)(router, "GET", `${BASE_PATH}/components/pricing_table`, {
-    handler: getPricingTableHandler,
-    requireCustomer: false
-  });
-  addGenRoutes(router);
-  addEntityRoutes(router);
-  addReferralRoutes(router);
-  addProductRoutes(router);
-  return router;
-};
-
-// src/libraries/backend/utils/secretKeyCheck.ts
-var secretKeyCheck = (secretKey) => {
-  if (!secretKey && !process.env.AUTUMN_SECRET_KEY) {
-    return {
-      found: false,
-      error: {
-        statusCode: 500,
-        message: `Autumn secret key not found in ENV variables or passed into autumnHandler`,
-        code: "no_secret_key"
-      }
-    };
-  }
-  return { found: true, error: null };
-};
-
-// src/libraries/backend/convex.ts
-var import_rou36 = require("rou3");
-function autumnHandler(options) {
-  const router = createRouterWithOptions();
-  return options.httpAction(async (ctx, request) => {
-    const headers = request.headers;
-    if (headers.get("Origin") !== null && headers.get("Access-Control-Request-Method") !== null && headers.get("Access-Control-Request-Headers") !== null) {
-      return new Response(null, {
-        headers: new Headers({
-          // e.g. https://mywebsite.com, configured on your Convex dashboard, or passed in as an option
-          "Access-Control-Allow-Origin": process.env.CLIENT_ORIGIN ?? "http://localhost:3000",
-          "Access-Control-Allow-Methods": "POST, GET, PATCH, DELETE, OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type, Digest, Authorization, Cookie",
-          "Access-Control-Allow-Credentials": "true",
-          "Access-Control-Max-Age": "86400"
-        })
-      });
-    }
-    let { found, error: resError } = secretKeyCheck(options.secretKey);
-    if (!found && !options.secretKey) {
-      return Response.json(resError, { status: resError.statusCode });
-    }
-    const method = request.method;
-    const url = new URL(request.url);
-    const searchParams = Object.fromEntries(url.searchParams);
-    const pathname = url.pathname;
-    const match = (0, import_rou36.findRoute)(router, method, pathname);
-    if (!match) {
-      return Response.json({ error: "Not found" }, { status: 404 });
-    }
-    const { data, params: pathParams } = match;
-    const { handler } = data;
-    const autumn = new Autumn({
-      secretKey: options.secretKey || void 0,
-      url: options.url
-    });
-    let body = null;
-    if (method === "POST" || method === "PUT" || method === "PATCH") {
-      try {
-        body = await request.json();
-      } catch (error) {
-      }
-    }
-    const result = await handler({
-      autumn,
-      body,
-      path: url.pathname,
-      getCustomer: async () => await options.identify(ctx, request),
-      pathParams,
-      searchParams
-    });
-    return Response.json(result.body, {
-      status: result.statusCode,
-      headers: new Headers({
-        "Access-Control-Allow-Origin": process.env.CLIENT_ORIGIN ?? "http://localhost:3000",
-        "Access-Control-Allow-Credentials": "true",
-        Vary: "origin"
-      })
-    });
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  autumnHandler
-});