autumn-js 0.0.92 → 0.0.95

package/dist/libraries/react/hooks/useAutumn.js

@@ -529,44 +529,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_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 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 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",
@@ -576,14 +628,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
@@ -601,7 +667,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;
 }
 
@@ -610,7 +676,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;
 };
 
@@ -646,17 +712,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;
 }
 
@@ -664,51 +730,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;
 }
 
@@ -718,23 +784,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, {
@@ -914,6 +988,9 @@ var useAutumnContext = ({
   errorIfNotInitialized = true
 }) => {
   const context = (0, import_react.useContext)(AutumnContext2);
+  if (!context.initialized && errorIfNotInitialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
   return context;
 };
 

package/dist/libraries/react/hooks/useAutumn.mjs

@@ -2,20 +2,20 @@
 
 import {
   useAutumn
-} from "../chunk-SDZ5NW6G.mjs";
-import "../chunk-RZW3QO6B.mjs";
-import "../chunk-TCCWWPEC.mjs";
-import "../chunk-HL4JNKWK.mjs";
-import "../chunk-NCPXL3J2.mjs";
-import "../chunk-V5PKOA5A.mjs";
-import "../chunk-JNM4BLTM.mjs";
-import "../chunk-YUV2Y2RW.mjs";
-import "../chunk-3EYF7OI5.mjs";
-import "../chunk-KQT5G3HT.mjs";
+} from "../chunk-MZDRIPNS.mjs";
+import "../chunk-LVDONEVF.mjs";
+import "../chunk-R4BYOLST.mjs";
+import "../chunk-G3FBFZLU.mjs";
+import "../chunk-ALFXUHDD.mjs";
 import "../chunk-JVCOY7ZL.mjs";
 import "../chunk-CIBQ4BJU.mjs";
-import "../chunk-NZ5PEXT2.mjs";
-import "../chunk-TGX6UKKS.mjs";
+import "../chunk-V575SGOW.mjs";
+import "../chunk-ZV4RPZTM.mjs";
+import "../chunk-VTGR7VVK.mjs";
+import "../chunk-WFFVOEUG.mjs";
+import "../chunk-ZF2HUCN6.mjs";
+import "../chunk-VUBJ6JM3.mjs";
+import "../chunk-KQT5G3HT.mjs";
 export {
   useAutumn
 };

package/dist/libraries/react/hooks/useAutumnBase.d.mts

@@ -1,13 +1,13 @@
-import { A as AutumnPromise, b as CheckResult, T as TrackResult, C as CancelResult, S as SetupPaymentResult } from '../response-Bt5OMm4y.mjs';
-import { B as BillingPortalResult } from '../cusTypes-WaPJKeAb.mjs';
+import { A as AutumnPromise, b as CheckResult, T as TrackResult, C as CancelResult, S as SetupPaymentResult } from '../response-CWluLfIs.mjs';
+import { B as BillingPortalResult } from '../cusTypes-Vw94kPR9.mjs';
 import { AutumnContextParams } from '../AutumnContext.mjs';
 import { AttachParams, CheckParams, TrackParams, CancelParams, OpenBillingPortalParams, SetupPaymentParams } from '../client/types/clientGenTypes.mjs';
 import 'zod';
 import '../error-DHbclCVh.mjs';
 import 'react';
-import '../ReactAutumnClient-BmHGkNH1.mjs';
+import '../ReactAutumnClient-BuSRDMJN.mjs';
 import '../client/types/clientEntTypes.mjs';
-import '../entTypes-aIV0QUCW.mjs';
+import '../entTypes-Ho-VocKG.mjs';
 
 declare const useAutumnBase: ({ AutumnContext, authClient, }: {
     AutumnContext: React.Context<AutumnContextParams>;

package/dist/libraries/react/hooks/useAutumnBase.d.ts

@@ -1,13 +1,13 @@
-import { A as AutumnPromise, b as CheckResult, T as TrackResult, C as CancelResult, S as SetupPaymentResult } from '../response-CvPzWrT9.js';
-import { B as BillingPortalResult } from '../cusTypes-WaPJKeAb.js';
+import { A as AutumnPromise, b as CheckResult, T as TrackResult, C as CancelResult, S as SetupPaymentResult } from '../response-CQf3mDB8.js';
+import { B as BillingPortalResult } from '../cusTypes-Vw94kPR9.js';
 import { AutumnContextParams } from '../AutumnContext.js';
 import { AttachParams, CheckParams, TrackParams, CancelParams, OpenBillingPortalParams, SetupPaymentParams } from '../client/types/clientGenTypes.js';
 import 'zod';
 import '../error-DHbclCVh.js';
 import 'react';
-import '../ReactAutumnClient-PGnPqPkr.js';
+import '../ReactAutumnClient-k0qbHX8f.js';
 import '../client/types/clientEntTypes.js';
-import '../entTypes-D01S8gFX.js';
+import '../entTypes-B7nuhHD7.js';
 
 declare const useAutumnBase: ({ AutumnContext, authClient, }: {
     AutumnContext: React.Context<AutumnContextParams>;