autumn-js 0.0.92 → 0.0.95

package/dist/libraries/react/index.js

@@ -581,44 +581,96 @@ var Autumn = class {
   }
 };
 
-// src/sdk/general/genTypes.ts
+// src/sdk/customers/entities/entTypes.ts
 var import_zod = require("zod");
-var AttachParamsSchema = import_zod.z.object({
-  customer_id: import_zod.z.string(),
-  product_id: import_zod.z.string().optional(),
-  entity_id: import_zod.z.string().optional(),
-  options: import_zod.z.array(import_zod.z.object({
-    feature_id: import_zod.z.string(),
-    quantity: import_zod.z.number()
-  })).optional(),
-  product_ids: import_zod.z.array(import_zod.z.string()).optional(),
+var EntityDataSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  feature_id: import_zod.z.string()
+});
+
+// src/sdk/general/genTypes.ts
+var import_zod2 = require("zod");
+var AttachFeatureOptionsSchema = import_zod2.z.object({
+  feature_id: import_zod2.z.string(),
+  quantity: import_zod2.z.number()
+});
+var AttachParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  product_id: import_zod2.z.string().optional(),
+  entity_id: import_zod2.z.string().optional(),
+  options: import_zod2.z.array(
+    import_zod2.z.object({
+      feature_id: import_zod2.z.string(),
+      quantity: import_zod2.z.number()
+    })
+  ).optional(),
+  product_ids: import_zod2.z.array(import_zod2.z.string()).optional(),
   // If set, will attach multiple products to the customer (cannot be used with product_id)
-  free_trial: import_zod.z.boolean().optional(),
+  free_trial: import_zod2.z.boolean().optional(),
   // Default is true -- if set to false, will bypass product free trial
-  success_url: import_zod.z.string().optional(),
+  success_url: import_zod2.z.string().optional(),
   // Passed to Stripe
-  metadata: import_zod.z.record(import_zod.z.string()).optional(),
+  metadata: import_zod2.z.record(import_zod2.z.string()).optional(),
   // Passed to Stripe
-  force_checkout: import_zod.z.boolean().optional(),
+  force_checkout: import_zod2.z.boolean().optional(),
   // Default is false -- if set to true, will force the customer to checkout (not allowed for upgrades / downgrades)
-  customer_data: import_zod.z.any().optional(),
-  entity_data: import_zod.z.any().optional(),
-  checkout_session_params: import_zod.z.record(import_zod.z.any()).optional(),
+  customer_data: import_zod2.z.any().optional(),
+  entity_data: import_zod2.z.any().optional(),
+  checkout_session_params: import_zod2.z.record(import_zod2.z.any()).optional(),
   // Passed to Stripe
-  reward: import_zod.z.string().optional()
+  reward: import_zod2.z.string().optional()
 });
-var AttachResultSchema = import_zod.z.object({
-  checkout_url: import_zod.z.string().optional(),
-  customer_id: import_zod.z.string(),
-  product_ids: import_zod.z.array(import_zod.z.string()),
-  code: import_zod.z.string(),
-  message: import_zod.z.string(),
-  customer_data: import_zod.z.any().optional()
+var AttachResultSchema = import_zod2.z.object({
+  checkout_url: import_zod2.z.string().optional(),
+  customer_id: import_zod2.z.string(),
+  product_ids: import_zod2.z.array(import_zod2.z.string()),
+  code: import_zod2.z.string(),
+  message: import_zod2.z.string(),
+  customer_data: import_zod2.z.any().optional()
+});
+var CancelParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  product_id: import_zod2.z.string(),
+  entity_id: import_zod2.z.string().optional(),
+  cancel_immediately: import_zod2.z.boolean().optional()
+});
+var CancelResultSchema = import_zod2.z.object({
+  success: import_zod2.z.boolean(),
+  customer_id: import_zod2.z.string(),
+  product_id: import_zod2.z.string()
+});
+var TrackParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  value: import_zod2.z.number().optional(),
+  feature_id: import_zod2.z.string().optional(),
+  event_name: import_zod2.z.string().optional(),
+  entity_id: import_zod2.z.string().optional(),
+  customer_data: import_zod2.z.any().optional(),
+  idempotency_key: import_zod2.z.string().optional(),
+  entity_data: import_zod2.z.any().optional()
+});
+var TrackResultSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  code: import_zod2.z.string(),
+  customer_id: import_zod2.z.string(),
+  feature_id: import_zod2.z.string().optional(),
+  event_name: import_zod2.z.string().optional()
+});
+var CheckParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  feature_id: import_zod2.z.string().optional(),
+  product_id: import_zod2.z.string().optional(),
+  entity_id: import_zod2.z.string().optional(),
+  customer_data: import_zod2.z.any().optional(),
+  required_balance: import_zod2.z.number().optional(),
+  send_event: import_zod2.z.boolean().optional(),
+  with_preview: import_zod2.z.boolean().optional(),
+  entity_data: EntityDataSchema.optional()
 });
 
 // src/sdk/customers/cusEnums.ts
-var import_zod2 = require("zod");
-var CustomerExpandEnum = import_zod2.z.enum([
+var import_zod3 = require("zod");
+var CustomerExpandEnum = import_zod3.z.enum([
   "invoices",
   "rewards",
   "trials_used",
@@ -628,14 +680,28 @@ var CustomerExpandEnum = import_zod2.z.enum([
 ]);
 
 // src/sdk/customers/cusTypes.ts
-var import_zod3 = require("zod");
-var CreateCustomerParamsSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  email: import_zod3.z.string().nullish(),
-  name: import_zod3.z.string().nullish(),
-  fingerprint: import_zod3.z.string().nullish(),
-  metadata: import_zod3.z.record(import_zod3.z.any()).optional(),
-  expand: import_zod3.z.array(CustomerExpandEnum).optional()
+var import_zod4 = require("zod");
+var CreateCustomerParamsSchema = import_zod4.z.object({
+  id: import_zod4.z.string().nullish(),
+  email: import_zod4.z.string().nullish(),
+  name: import_zod4.z.string().nullish(),
+  fingerprint: import_zod4.z.string().nullish(),
+  metadata: import_zod4.z.record(import_zod4.z.any()).optional(),
+  expand: import_zod4.z.array(CustomerExpandEnum).optional()
+});
+var BillingPortalParamsSchema = import_zod4.z.object({
+  return_url: import_zod4.z.string().optional()
+});
+
+// src/sdk/referrals/referralTypes.ts
+var import_zod5 = require("zod");
+var CreateReferralCodeParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  program_id: import_zod5.z.string()
+});
+var RedeemReferralCodeParamsSchema = import_zod5.z.object({
+  code: import_zod5.z.string(),
+  customer_id: import_zod5.z.string()
 });
 
 // src/libraries/react/errorUtils/logFetchError.ts
@@ -653,7 +719,7 @@ var logFetchError = ({
 
 // src/libraries/react/client/clientCompMethods.ts
 async function getPricingTableMethod() {
-  const res = await this.get("/api/autumn/components/pricing_table");
+  const res = await this.get(`${this.prefix}/components/pricing_table`);
   return res;
 }
 
@@ -662,7 +728,7 @@ var createCustomerMethod = async ({
   client,
   params
 }) => {
-  let result = await client.post("/api/autumn/customers", params);
+  let result = await client.post(`${client.prefix}/customers`, params);
   return result;
 };
 
@@ -698,17 +764,17 @@ var getEntityExpandStr = (expand) => {
 // src/libraries/react/client/clientEntityMethods.ts
 async function createEntityMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/entities", snakeParams);
+  const res = await this.post(`${this.prefix}/entities`, snakeParams);
   return res;
 }
 async function getEntityMethod(entityId, params) {
   let snakeParams = toSnakeCase(params);
   let expand = getEntityExpandStr(params?.expand);
-  const res = await this.get(`/api/autumn/entities/${entityId}?${expand}`);
+  const res = await this.get(`${this.prefix}/entities/${entityId}?${expand}`);
   return res;
 }
 async function deleteEntityMethod(entityId) {
-  const res = await this.delete(`/api/autumn/entities/${entityId}`);
+  const res = await this.delete(`${this.prefix}/entities/${entityId}`);
   return res;
 }
 
@@ -716,51 +782,51 @@ async function deleteEntityMethod(entityId) {
 async function attachMethod(params) {
   let { dialog, ...rest } = params;
   let snakeParams = toSnakeCase(rest, ["checkoutSessionparams"]);
-  const res = await this.post("/api/autumn/attach", snakeParams);
+  const res = await this.post(`${this.prefix}/attach`, snakeParams);
   return res;
 }
 async function setupPaymentMethod(params) {
   let snakeParams = toSnakeCase(params, ["checkoutSessionParams"]);
-  const res = await this.post("/api/autumn/setup_payment", snakeParams);
+  const res = await this.post(`${this.prefix}/setup_payment`, snakeParams);
   return res;
 }
 async function cancelMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/cancel", snakeParams);
+  const res = await this.post(`${this.prefix}/cancel`, snakeParams);
   return res;
 }
 async function checkMethod(params) {
   let { dialog, ...rest } = params;
   let snakeParams = toSnakeCase(rest);
-  const res = await this.post("/api/autumn/check", snakeParams);
+  const res = await this.post(`${this.prefix}/check`, snakeParams);
   return res;
 }
 async function trackMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/track", snakeParams);
+  const res = await this.post(`${this.prefix}/track`, snakeParams);
   return res;
 }
 async function openBillingPortalMethod(params) {
   let snakeParams = toSnakeCase(params || {});
-  const res = await this.post("/api/autumn/billing_portal", snakeParams);
+  const res = await this.post(`${this.prefix}/billing_portal`, snakeParams);
   return res;
 }
 
 // src/libraries/react/client/clientProdMethods.ts
 async function listProductsMethod() {
-  const res = await this.get("/api/autumn/products");
+  const res = await this.get(`${this.prefix}/products`);
   return res;
 }
 
 // src/libraries/react/client/clientReferralMethods.ts
 async function createCode(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/referrals/code", snakeParams);
+  const res = await this.post(`${this.prefix}/referrals/code`, snakeParams);
   return res;
 }
 async function redeemCode(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/referrals/redeem", snakeParams);
+  const res = await this.post(`${this.prefix}/referrals/redeem`, snakeParams);
   return res;
 }
 
@@ -770,23 +836,31 @@ var AutumnClient = class {
   getBearerToken;
   customerData;
   includeCredentials;
-  corsDetected;
-  corsSupportsCredentials;
+  prefix;
   constructor({
     backendUrl,
     getBearerToken,
     customerData,
-    includeCredentials
+    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, {
@@ -966,6 +1040,9 @@ var useAutumnContext = ({
   errorIfNotInitialized = true
 }) => {
   const context = (0, import_react2.useContext)(AutumnContext2);
+  if (!context.initialized && errorIfNotInitialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
   return context;
 };
 
@@ -1418,21 +1495,19 @@ var useCustomerBase = ({
   AutumnContext: AutumnContext2,
   client
 }) => {
-  const queryKey = ["customer", params?.expand];
   let context;
-  let authClientExists = !!params?.authClient;
   if (AutumnContext2) {
     context = useAutumnContext({
       AutumnContext: AutumnContext2,
-      name: "useCustomer",
-      errorIfNotInitialized: !authClientExists
+      name: "useCustomer"
+      // errorIfNotInitialized: !authClientExists,
     });
   }
-  if (authClientExists) {
-    client = params?.authClient?.autumn;
-  } else if (!client) {
+  if (!client) {
     client = context.client;
   }
+  let baseUrl = client?.backendUrl || "";
+  const queryKey = ["customer", baseUrl, params?.expand];
   const fetchCustomer = async () => {
     const { data, error: error2 } = await client.createCustomer({
       errorOnNotFound: params?.errorOnNotFound,
@@ -1456,10 +1531,9 @@ var useCustomerBase = ({
     ...params?.swrConfig
   });
   let autumnFunctions = emptyDefaultFunctions;
-  if (AutumnContext2 || params?.authClient) {
+  if (AutumnContext2) {
     autumnFunctions = useAutumnBase({
-      AutumnContext: AutumnContext2,
-      authClient: params?.authClient
+      AutumnContext: AutumnContext2
     });
   }
   return {
@@ -1562,13 +1636,14 @@ var ReactAutumnProvider = ({
   backendUrl,
   customerData,
   includeCredentials,
-  authClient
+  betterAuthUrl
 }) => {
   let client = new AutumnClient({
     backendUrl: getBackendUrl(backendUrl),
     getBearerToken,
     customerData,
-    includeCredentials
+    includeCredentials,
+    betterAuthUrl
   });
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(BaseAutumnProvider, { client, AutumnContext, children });
 };