autumn-js 0.0.108 → 0.0.110

package/dist/libraries/react/{chunk-2PVRCDDK.mjs → chunk-D3GL2QV3.mjs}

@@ -1,38 +1,5 @@
 "use client";
 
-import {
-  listProductsMethod
-} from "./chunk-V575SGOW.mjs";
-import {
-  createCode,
-  redeemCode
-} from "./chunk-ZV4RPZTM.mjs";
-import {
-  logAuthError
-} from "./chunk-JVCOY7ZL.mjs";
-import {
-  logFetchError
-} from "./chunk-CIBQ4BJU.mjs";
-import {
-  getPricingTableMethod
-} from "./chunk-VTGR7VVK.mjs";
-import {
-  createCustomerMethod
-} from "./chunk-WFFVOEUG.mjs";
-import {
-  createEntityMethod,
-  deleteEntityMethod,
-  getEntityMethod
-} from "./chunk-ZF2HUCN6.mjs";
-import {
-  attachMethod,
-  cancelMethod,
-  checkMethod,
-  checkoutMethod,
-  openBillingPortalMethod,
-  setupPaymentMethod,
-  trackMethod
-} from "./chunk-253MTZP3.mjs";
 
 // src/sdk/error.ts
 var AutumnError = class _AutumnError extends Error {
@@ -60,6 +27,193 @@ var AutumnError = class _AutumnError extends Error {
   }
 };
 
+// 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/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
+import { z } from "zod";
+var CustomerExpandEnum = z.enum([
+  "invoices",
+  "rewards",
+  "trials_used",
+  "entities",
+  "referrals",
+  "payment_method"
+]);
+
+// src/sdk/customers/cusTypes.ts
+import { z as z2 } from "zod";
+var CoreCusFeatureSchema = z2.object({
+  unlimited: z2.boolean().optional(),
+  interval: z2.nativeEnum(ProductItemInterval).optional(),
+  balance: z2.number().optional(),
+  usage: z2.number().optional(),
+  included_usage: z2.number().optional(),
+  next_reset_at: z2.number().optional(),
+  overage_allowed: z2.boolean().optional(),
+  usage_limit: z2.number().optional(),
+  breakdown: z2.array(
+    z2.object({
+      interval: z2.nativeEnum(ProductItemInterval),
+      balance: z2.number().optional(),
+      usage: z2.number().optional(),
+      included_usage: z2.number().optional(),
+      next_reset_at: z2.number().optional()
+    })
+  ).optional(),
+  credit_schema: z2.array(
+    z2.object({
+      feature_id: z2.string(),
+      credit_amount: z2.number()
+    })
+  ).optional()
+});
+var CustomerDataSchema = z2.object({
+  name: z2.string().nullish(),
+  email: z2.string().nullish(),
+  fingerprint: z2.string().nullish()
+});
+var CreateCustomerParamsSchema = z2.object({
+  id: z2.string().nullish(),
+  email: z2.string().nullish(),
+  name: z2.string().nullish(),
+  fingerprint: z2.string().nullish(),
+  metadata: z2.record(z2.any()).optional(),
+  expand: z2.array(CustomerExpandEnum).optional()
+});
+var BillingPortalParamsSchema = z2.object({
+  return_url: z2.string().optional()
+});
+
+// src/sdk/general/checkTypes.ts
+import { z as z3 } from "zod";
+var CheckFeatureResultSchema = z3.object({
+  allowed: z3.boolean(),
+  feature_id: z3.string(),
+  customer_id: z3.string(),
+  entity_id: z3.string().optional(),
+  required_balance: z3.number()
+}).extend(CoreCusFeatureSchema.shape);
+
+// src/sdk/customers/entities/entTypes.ts
+import { z as z4 } from "zod";
+var EntityDataSchema = z4.object({
+  name: z4.string().optional(),
+  feature_id: z4.string()
+});
+
+// src/sdk/general/genTypes.ts
+import { z as z5 } from "zod";
+var CancelParamsSchema = z5.object({
+  customer_id: z5.string(),
+  product_id: z5.string(),
+  entity_id: z5.string().optional(),
+  cancel_immediately: z5.boolean().optional()
+});
+var CancelResultSchema = z5.object({
+  success: z5.boolean(),
+  customer_id: z5.string(),
+  product_id: z5.string()
+});
+var TrackParamsSchema = z5.object({
+  customer_id: z5.string(),
+  value: z5.number().optional(),
+  feature_id: z5.string().optional(),
+  event_name: z5.string().optional(),
+  entity_id: z5.string().optional(),
+  customer_data: z5.any().optional(),
+  idempotency_key: z5.string().optional(),
+  entity_data: z5.any().optional()
+});
+var TrackResultSchema = z5.object({
+  id: z5.string(),
+  code: z5.string(),
+  customer_id: z5.string(),
+  feature_id: z5.string().optional(),
+  event_name: z5.string().optional()
+});
+var CheckParamsSchema = z5.object({
+  customer_id: z5.string(),
+  feature_id: z5.string().optional(),
+  product_id: z5.string().optional(),
+  entity_id: z5.string().optional(),
+  customer_data: z5.any().optional(),
+  required_balance: z5.number().optional(),
+  send_event: z5.boolean().optional(),
+  with_preview: z5.boolean().optional(),
+  entity_data: EntityDataSchema.optional()
+});
+var QueryRangeEnum = z5.enum(["24h", "7d", "30d", "90d", "last_cycle"]);
+var QueryParamsSchema = z5.object({
+  customer_id: z5.string(),
+  feature_id: z5.string().or(z5.array(z5.string())),
+  range: QueryRangeEnum.optional()
+});
+
 // src/sdk/general/genMethods.ts
 var handleCheckout = async ({
   instance,
@@ -103,6 +257,12 @@ var handleCheck = async ({
 }) => {
   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";
@@ -279,59 +439,6 @@ var redeemReferralCode = async ({
   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
 import chalk from "chalk";
 var getTime = () => {
@@ -480,315 +587,67 @@ var Autumn = class {
       params
     });
   }
+  static query = (params) => staticWrapper(handleQuery, void 0, { params });
+  async query(params) {
+    return handleQuery({
+      instance: this,
+      params
+    });
+  }
 };
 
-// src/sdk/customers/entities/entTypes.ts
-import { z } from "zod";
-var EntityDataSchema = z.object({
-  name: z.string().optional(),
-  feature_id: z.string()
-});
-
-// src/sdk/general/genTypes.ts
-import { z as z2 } from "zod";
-var CancelParamsSchema = z2.object({
-  customer_id: z2.string(),
-  product_id: z2.string(),
-  entity_id: z2.string().optional(),
-  cancel_immediately: z2.boolean().optional()
-});
-var CancelResultSchema = z2.object({
-  success: z2.boolean(),
-  customer_id: z2.string(),
-  product_id: z2.string()
-});
-var TrackParamsSchema = z2.object({
-  customer_id: z2.string(),
-  value: z2.number().optional(),
-  feature_id: z2.string().optional(),
-  event_name: z2.string().optional(),
-  entity_id: z2.string().optional(),
-  customer_data: z2.any().optional(),
-  idempotency_key: z2.string().optional(),
-  entity_data: z2.any().optional()
-});
-var TrackResultSchema = z2.object({
-  id: z2.string(),
-  code: z2.string(),
-  customer_id: z2.string(),
-  feature_id: z2.string().optional(),
-  event_name: z2.string().optional()
-});
-var CheckParamsSchema = z2.object({
-  customer_id: z2.string(),
-  feature_id: z2.string().optional(),
-  product_id: z2.string().optional(),
-  entity_id: z2.string().optional(),
-  customer_data: z2.any().optional(),
-  required_balance: z2.number().optional(),
-  send_event: z2.boolean().optional(),
-  with_preview: z2.boolean().optional(),
-  entity_data: EntityDataSchema.optional()
-});
-
-// src/sdk/customers/cusEnums.ts
-import { z as z3 } from "zod";
-var CustomerExpandEnum = z3.enum([
-  "invoices",
-  "rewards",
-  "trials_used",
-  "entities",
-  "referrals",
-  "payment_method"
-]);
-
-// src/sdk/customers/cusTypes.ts
-import { z as z4 } from "zod";
-var CustomerDataSchema = z4.object({
-  name: z4.string().nullish(),
-  email: z4.string().nullish(),
-  fingerprint: z4.string().nullish()
-});
-var CreateCustomerParamsSchema = z4.object({
-  id: z4.string().nullish(),
-  email: z4.string().nullish(),
-  name: z4.string().nullish(),
-  fingerprint: z4.string().nullish(),
-  metadata: z4.record(z4.any()).optional(),
-  expand: z4.array(CustomerExpandEnum).optional()
-});
-var BillingPortalParamsSchema = z4.object({
-  return_url: z4.string().optional()
-});
-
 // src/sdk/referrals/referralTypes.ts
-import { z as z5 } from "zod";
-var CreateReferralCodeParamsSchema = z5.object({
-  customer_id: z5.string(),
-  program_id: z5.string()
+import { z as z6 } from "zod";
+var CreateReferralCodeParamsSchema = z6.object({
+  customer_id: z6.string(),
+  program_id: z6.string()
 });
-var RedeemReferralCodeParamsSchema = z5.object({
-  code: z5.string(),
-  customer_id: z5.string()
+var RedeemReferralCodeParamsSchema = z6.object({
+  code: z6.string(),
+  customer_id: z6.string()
 });
 
 // src/sdk/general/attachTypes.ts
-import { z as z6 } from "zod";
-var AttachFeatureOptionsSchema = z6.object({
-  feature_id: z6.string(),
-  quantity: z6.number()
+import { z as z7 } from "zod";
+var AttachFeatureOptionsSchema = z7.object({
+  feature_id: z7.string(),
+  quantity: z7.number()
 });
-var AttachParamsSchema = z6.object({
-  customer_id: z6.string(),
-  product_id: z6.string().optional(),
-  entity_id: z6.string().optional(),
-  options: z6.array(AttachFeatureOptionsSchema).optional(),
-  product_ids: z6.array(z6.string()).optional(),
-  free_trial: z6.boolean().optional(),
-  success_url: z6.string().optional(),
-  metadata: z6.record(z6.string()).optional(),
-  force_checkout: z6.boolean().optional(),
+var AttachParamsSchema = z7.object({
+  customer_id: z7.string(),
+  product_id: z7.string().optional(),
+  entity_id: z7.string().optional(),
+  options: z7.array(AttachFeatureOptionsSchema).optional(),
+  product_ids: z7.array(z7.string()).optional(),
+  free_trial: z7.boolean().optional(),
+  success_url: z7.string().optional(),
+  metadata: z7.record(z7.string()).optional(),
+  force_checkout: z7.boolean().optional(),
   customer_data: CustomerDataSchema.optional(),
-  entity_data: z6.any().optional(),
-  checkout_session_params: z6.record(z6.any()).optional(),
-  reward: z6.string().optional()
+  entity_data: z7.any().optional(),
+  checkout_session_params: z7.record(z7.any()).optional(),
+  reward: z7.string().optional()
 });
-var AttachResultSchema = z6.object({
-  checkout_url: z6.string().optional(),
-  customer_id: z6.string(),
-  product_ids: z6.array(z6.string()),
-  code: z6.string(),
-  message: z6.string(),
-  customer_data: z6.any().optional()
+var AttachResultSchema = z7.object({
+  checkout_url: z7.string().optional(),
+  customer_id: z7.string(),
+  product_ids: z7.array(z7.string()),
+  code: z7.string(),
+  message: z7.string(),
+  customer_data: z7.any().optional()
 });
-var CheckoutParamsSchema = z6.object({
-  customer_id: z6.string(),
-  product_id: z6.string(),
-  entity_id: z6.string().optional(),
-  success_url: z6.string().optional(),
+var CheckoutParamsSchema = z7.object({
+  customer_id: z7.string(),
+  product_id: z7.string(),
+  entity_id: z7.string().optional(),
+  success_url: z7.string().optional(),
   customer_data: CustomerDataSchema.optional(),
-  options: z6.array(AttachFeatureOptionsSchema).optional()
+  options: z7.array(AttachFeatureOptionsSchema).optional()
 });
 
-// src/libraries/react/client/ReactAutumnClient.tsx
-var AutumnClient = class {
-  backendUrl;
-  getBearerToken;
-  customerData;
-  includeCredentials;
-  prefix;
-  constructor({
-    backendUrl,
-    getBearerToken,
-    customerData,
-    includeCredentials,
-    betterAuthUrl
-  }) {
-    this.backendUrl = backendUrl;
-    this.getBearerToken = getBearerToken;
-    this.customerData = customerData;
-    this.includeCredentials = includeCredentials;
-    this.prefix = "/api/autumn";
-    if (betterAuthUrl) {
-      this.prefix = "/api/auth/autumn";
-      this.backendUrl = betterAuthUrl;
-    }
-  }
-  /**
-   * Detects if the backend supports CORS credentials by making an OPTIONS request
-   */
-  async detectCors() {
-    if (this.prefix?.includes("/api/auth")) {
-      return { valid: true, includeCredentials: true };
-    }
-    const testEndpoint = `${this.backendUrl}/api/autumn/cors`;
-    try {
-      await fetch(testEndpoint, {
-        method: "POST",
-        credentials: "include",
-        headers: { "Content-Type": "application/json" }
-      });
-      return { valid: true, includeCredentials: true };
-    } catch (error) {
-      try {
-        await fetch(testEndpoint, {
-          method: "POST",
-          credentials: "omit",
-          headers: { "Content-Type": "application/json" }
-        });
-        return { valid: true, includeCredentials: false };
-      } catch (error2) {
-        return { valid: false, includeCredentials: void 0 };
-      }
-    }
-  }
-  /**
-   * Automatically determines whether to include credentials based on CORS detection
-   */
-  async shouldIncludeCredentials() {
-    if (this.includeCredentials !== void 0) {
-      return this.includeCredentials;
-    }
-    try {
-      const corsResult = await this.detectCors();
-      if (corsResult.valid) {
-        console.warn(
-          `[Autumn] Detected CORS credentials: ${corsResult.includeCredentials}`
-        );
-        console.warn(
-          `[Autumn] To disable this warning, you can set includeCredentials={${corsResult.includeCredentials ? "true" : "false"}} in <AutumnProvider />`
-        );
-        this.includeCredentials = corsResult.includeCredentials;
-      }
-      return corsResult.includeCredentials || false;
-    } catch (error) {
-      console.error(`[Autumn] Error detecting CORS: ${error.message}`);
-      return false;
-    }
-  }
-  async getHeaders() {
-    let headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.getBearerToken) {
-      try {
-        let token = await this.getBearerToken();
-        headers.Authorization = `Bearer ${token}`;
-      } catch (error) {
-        console.error(`Failed to call getToken() in AutumnProvider`);
-      }
-    }
-    return headers;
-  }
-  async handleFetch({
-    path,
-    method,
-    body
-  }) {
-    body = method === "POST" ? JSON.stringify({
-      ...body,
-      customer_data: this.customerData || void 0
-    }) : void 0;
-    const includeCredentials = await this.shouldIncludeCredentials();
-    try {
-      const response = await fetch(`${this.backendUrl}${path}`, {
-        method,
-        body,
-        headers: await this.getHeaders(),
-        credentials: includeCredentials ? "include" : "omit"
-      });
-      const loggedError = await logAuthError(response);
-      return await toContainerResult({
-        response,
-        logger: console,
-        logError: !loggedError
-      });
-    } catch (error) {
-      logFetchError({
-        method,
-        backendUrl: this.backendUrl || "",
-        path,
-        error
-      });
-      return {
-        data: null,
-        error: new AutumnError({
-          message: error.message,
-          code: "fetch_failed"
-        })
-      };
-    }
-  }
-  async post(path, body) {
-    return await this.handleFetch({
-      path,
-      method: "POST",
-      body
-    });
-  }
-  async get(path) {
-    return await this.handleFetch({
-      path,
-      method: "GET"
-    });
-  }
-  async delete(path) {
-    return await this.handleFetch({
-      path,
-      method: "DELETE"
-    });
-  }
-  async createCustomer(params) {
-    return await createCustomerMethod({
-      client: this,
-      params
-    });
-  }
-  async getPricingTable() {
-    return await getPricingTableMethod.bind(this)();
-  }
-  attach = attachMethod.bind(this);
-  checkout = checkoutMethod.bind(this);
-  cancel = cancelMethod.bind(this);
-  check = checkMethod.bind(this);
-  track = trackMethod.bind(this);
-  openBillingPortal = openBillingPortalMethod.bind(this);
-  setupPayment = setupPaymentMethod.bind(this);
-  entities = {
-    create: createEntityMethod.bind(this),
-    get: getEntityMethod.bind(this),
-    delete: deleteEntityMethod.bind(this)
-  };
-  referrals = {
-    createCode: createCode.bind(this),
-    redeemCode: redeemCode.bind(this)
-  };
-  products = {
-    list: listProductsMethod.bind(this)
-  };
-};
-
 export {
   AutumnError,
-  AutumnClient
+  toContainerResult,
+  CheckFeatureResultSchema,
+  QueryRangeEnum
 };

package/dist/libraries/react/{chunk-4CHWEUKX.mjs → chunk-FE5GYL7P.mjs}

@@ -2,10 +2,10 @@
 
 import {
   useCustomerBase
-} from "./chunk-OEIUKLFH.mjs";
+} from "./chunk-MIITU3Q2.mjs";
 import {
   AutumnContext
-} from "./chunk-LXD6AEZW.mjs";
+} from "./chunk-V2XCEJ4T.mjs";
 
 // src/libraries/react/hooks/useCustomer.tsx
 var useCustomer = (params) => {

package/dist/libraries/react/{chunk-MY2ODATB.mjs → chunk-HBCCTYA6.mjs}

@@ -3,6 +3,12 @@
 
 // src/libraries/react/components/check-dialog/lib/check-content.tsx
 var getCheckContent = (preview) => {
+  if (!preview) {
+    return {
+      title: "Feature Unavailable",
+      message: "This feature is not available for your account."
+    };
+  }
   const { scenario, products, feature_name } = preview;
   if (products.length == 0) {
     switch (scenario) {