autumn-js 0.0.65 → 0.0.67

package/dist/libraries/react/ReactAutumnProvider.mjs

@@ -2,15 +2,14 @@
 
 import {
   ReactAutumnProvider
-} from "./chunk-CZAUMPWK.mjs";
-import "./chunk-4TTWSWW7.mjs";
+} from "./chunk-2MVQH6J5.mjs";
+import "./chunk-NJFRQ6T4.mjs";
+import "./chunk-A6J237PD.mjs";
 import "./chunk-4QPHNIQ7.mjs";
-import "./chunk-Q5SSQSDP.mjs";
-import "./chunk-URAFNMTH.mjs";
-import "./chunk-PIIGEXKQ.mjs";
-import "./chunk-XTEUMENO.mjs";
-import "./chunk-XXOQMNM6.mjs";
-import "./chunk-OCZFV7OX.mjs";
+import "./chunk-EOSHPHLH.mjs";
+import "./chunk-XDAZD5HF.mjs";
+import "./chunk-JNJ53ZW6.mjs";
+import "./chunk-CIBQ4BJU.mjs";
 import "./chunk-LS3NB4DU.mjs";
 import "./chunk-TBCLSIC2.mjs";
 import "./chunk-NZ5PEXT2.mjs";

package/dist/libraries/react/{chunk-CZAUMPWK.mjs → chunk-2MVQH6J5.mjs}

@@ -2,10 +2,13 @@
 
 import {
   BaseAutumnProvider
-} from "./chunk-4TTWSWW7.mjs";
+} from "./chunk-NJFRQ6T4.mjs";
+import {
+  AutumnContext
+} from "./chunk-EOSHPHLH.mjs";
 import {
   AutumnClient
-} from "./chunk-XXOQMNM6.mjs";
+} from "./chunk-XDAZD5HF.mjs";
 
 // src/libraries/react/ReactAutumnProvider.tsx
 import { jsx } from "react/jsx-runtime";
@@ -16,13 +19,16 @@ var ReactAutumnProvider = ({
   customerData,
   includeCredentials = true
 }) => {
+  if (backendUrl && !backendUrl.startsWith("http")) {
+    console.warn(`backendUrl is not a valid URL: ${backendUrl}`);
+  }
   let client = new AutumnClient({
-    backendUrl,
+    backendUrl: backendUrl || "",
     getBearerToken,
     customerData,
     includeCredentials
   });
-  return /* @__PURE__ */ jsx(BaseAutumnProvider, { client, children });
+  return /* @__PURE__ */ jsx(BaseAutumnProvider, { client, AutumnContext, children });
 };
 
 export {

package/dist/libraries/react/chunk-57I3B4BV.mjs

@@ -0,0 +1,20 @@
+"use client";
+
+import {
+  usePricingTableBase
+} from "./chunk-PSE3LKMR.mjs";
+import {
+  AutumnContext
+} from "./chunk-EOSHPHLH.mjs";
+
+// src/libraries/react/hooks/usePricingTable.tsx
+var usePricingTable = (params) => {
+  return usePricingTableBase({
+    AutumnContext,
+    params
+  });
+};
+
+export {
+  usePricingTable
+};

package/dist/libraries/react/chunk-5S5BL6HV.mjs

@@ -0,0 +1,17 @@
+"use client";
+
+import {
+  useAutumnBase
+} from "./chunk-CQ27LXPH.mjs";
+import {
+  AutumnContext
+} from "./chunk-EOSHPHLH.mjs";
+
+// src/libraries/react/hooks/useAutumn.tsx
+var useAutumn = () => {
+  return useAutumnBase({ AutumnContext });
+};
+
+export {
+  useAutumn
+};

package/dist/libraries/react/chunk-A6J237PD.mjs

@@ -0,0 +1,57 @@
+"use client";
+
+import {
+  useAutumnContext
+} from "./chunk-EOSHPHLH.mjs";
+
+// src/libraries/react/hooks/useCustomerBase.tsx
+import useSWR from "swr";
+var useCustomerBase = ({
+  params,
+  AutumnContext,
+  client
+}) => {
+  const queryKey = ["customer"];
+  let context;
+  if (AutumnContext) {
+    context = useAutumnContext({ AutumnContext, name: "useCustomer" });
+  }
+  if (!client) {
+    client = context.client;
+  }
+  const fetchCustomer = async () => {
+    const { data: data2, error: error2 } = await client.createCustomer({
+      errorOnNotFound: params?.errorOnNotFound,
+      expand: params?.expand
+    });
+    if (error2) {
+      throw error2;
+    }
+    if (!data2) {
+      return null;
+    }
+    return data2;
+  };
+  const { data, error, isLoading, mutate } = useSWR(queryKey, fetchCustomer, {
+    fallbackData: null,
+    onErrorRetry: (error2, key, config) => {
+      if (error2.code == "entity_not_found") {
+        return false;
+      }
+      return true;
+    }
+  });
+  return {
+    customer: error ? null : data,
+    isLoading,
+    error,
+    refetch: mutate,
+    createEntity: client.entities.create,
+    createReferralCode: client.referrals.createCode,
+    redeemReferralCode: client.referrals.redeemCode
+  };
+};
+
+export {
+  useCustomerBase
+};

package/dist/{next/client/hooks/useEntityProvider.mjs → libraries/react/chunk-BGEO5REY.mjs}

@@ -1,20 +1,21 @@
 "use client";
 
+
+// src/libraries/react/hooks/useEntityBase.tsx
 import useSWR from "swr";
-import { getEntityAction } from "../../../next/server/cusActions";
-import { useAutumnContext } from "../AutumnContext";
-const useEntityProvider = (entityId, params) => {
-  const { encryptedCustomerId } = useAutumnContext();
+import { useContext } from "react";
+var useEntityBase = ({
+  entityId,
+  params,
+  AutumnContext
+}) => {
+  const { client } = useContext(AutumnContext);
   const queryKey = ["entity", entityId, params?.expand];
   const fetchEntity = async () => {
     if (!entityId) {
       return null;
     }
-    const { data: data2, error: error2 } = await getEntityAction({
-      encryptedCustomerId,
-      entityId,
-      params
-    });
+    const { data: data2, error: error2 } = await client.entities.get(entityId, params);
     if (error2) {
       throw error2;
     }
@@ -47,6 +48,7 @@ const useEntityProvider = (entityId, params) => {
     refetch: mutate
   };
 };
+
 export {
-  useEntityProvider
+  useEntityBase
 };

package/dist/libraries/react/chunk-CIBQ4BJU.mjs

@@ -0,0 +1,19 @@
+"use client";
+
+
+// src/libraries/react/errorUtils/logFetchError.ts
+var logFetchError = ({
+  method,
+  backendUrl,
+  path,
+  error
+}) => {
+  console.error(`[Autumn] Fetch failed: ${method} ${backendUrl}${path}
+
+1. Check that backendUrl in <AutumnProvider/> is correctly set.
+2. Check that autumnHandler is correctly registered on your backend.`);
+};
+
+export {
+  logFetchError
+};

package/dist/libraries/react/{chunk-WPXLFYWT.mjs → chunk-CQ27LXPH.mjs}

@@ -1,18 +1,22 @@
 "use client";
 
+import {
+  usePricingTableBase
+} from "./chunk-PSE3LKMR.mjs";
 import {
   useAutumnContext
-} from "./chunk-XTEUMENO.mjs";
+} from "./chunk-EOSHPHLH.mjs";
 
-// src/libraries/react/hooks/useAutumn.tsx
-var useAutumn = () => {
-  const { client } = useAutumnContext();
-  const {
-    prodChangeDialog,
-    paywallDialog,
-    pricingTableProvider,
-    customerProvider
-  } = useAutumnContext();
+// src/libraries/react/hooks/useAutumnBase.tsx
+var useAutumnBase = ({
+  AutumnContext
+}) => {
+  const context = useAutumnContext({ AutumnContext, name: "useAutumn" });
+  const { prodChangeDialog, paywallDialog } = context;
+  const client = context.client;
+  const { refetch: refetchPricingTable } = usePricingTableBase({
+    AutumnContext
+  });
   let {
     setProps: setProdChangeDialogProps,
     setOpen: setProdChangeDialogOpen,
@@ -24,23 +28,20 @@ var useAutumn = () => {
     setComponent: setPaywallComponent
   } = paywallDialog;
   const attachWithDialog = async (params) => {
-    const attachWithoutDialog = async (options) => {
-      let { dialog, ...rest } = params;
-      return await attach(rest);
-    };
+    let { dialog, ...rest } = params;
     const { productId, entityId, entityData } = params;
     const checkRes = await client.check({
       productId,
       entityId,
       entityData,
-      withPreview: "formatted"
+      withPreview: true
     });
     if (checkRes.error) {
       return checkRes;
     }
     let preview = checkRes.data.preview;
     if (!preview) {
-      return await attachWithoutDialog();
+      return await attach(rest);
     } else {
       setProdChangeDialogProps({
         preview
@@ -50,7 +51,7 @@ var useAutumn = () => {
     return checkRes;
   };
   const attach = async (params) => {
-    const { dialog, callback, openInNewTab } = params;
+    const { dialog, openInNewTab } = params;
     if (dialog) {
       setProdChangeComponent(dialog);
       return await attachWithDialog(params);
@@ -67,18 +68,7 @@ var useAutumn = () => {
         window.location.href = data.checkout_url;
       }
     }
-    try {
-      await callback?.();
-    } catch (error) {
-      return result;
-    }
-    await Promise.all([
-      pricingTableProvider.pricingTableProducts ? pricingTableProvider.refetch().catch((error) => {
-        console.warn("Failed to refetch pricing table data");
-        console.warn(error);
-      }) : Promise.resolve(),
-      customerProvider.refetchFirstTwo()
-    ]);
+    await refetchPricingTable();
     if (setProdChangeDialogOpen) {
       setProdChangeDialogOpen(false);
     }
@@ -98,7 +88,7 @@ var useAutumn = () => {
     }
     const res = await client.check({
       ...params,
-      withPreview: withPreview || dialog ? "formatted" : void 0
+      withPreview: withPreview || dialog ? true : false
     });
     if (res.error) {
       return res;
@@ -106,9 +96,7 @@ var useAutumn = () => {
     let data = res.data;
     if (data && data.preview && dialog) {
       let preview = data.preview;
-      setPaywallDialogProps({
-        preview
-      });
+      setPaywallDialogProps({ preview });
       setPaywallDialogOpen(true);
     }
     return res;
@@ -121,13 +109,24 @@ var useAutumn = () => {
     return res;
   };
   const openBillingPortal = async (params) => {
-    const res = await client.openBillingPortal(params);
+    let defaultParams = {
+      openInNewTab: false
+    };
+    let finalParams = {
+      ...defaultParams,
+      ...params
+    };
+    const res = await client.openBillingPortal(finalParams);
     if (res.error) {
       return res;
     }
     let data = res.data;
     if (data?.url && typeof window !== "undefined") {
-      window.open(data.url, "_blank");
+      if (finalParams.openInNewTab) {
+        window.open(data.url, "_blank");
+      } else {
+        window.open(data.url, "_self");
+      }
       return res;
     } else {
       return res;
@@ -143,5 +142,5 @@ var useAutumn = () => {
 };
 
 export {
-  useAutumn
+  useAutumnBase
 };

package/dist/libraries/react/chunk-DMU3G7UZ.mjs

@@ -0,0 +1,17 @@
+"use client";
+
+import {
+  useEntityBase
+} from "./chunk-BGEO5REY.mjs";
+import {
+  AutumnContext
+} from "./chunk-EOSHPHLH.mjs";
+
+// src/libraries/react/hooks/useEntity.tsx
+var useEntity = (entityId, params) => {
+  return useEntityBase({ AutumnContext, entityId, params });
+};
+
+export {
+  useEntity
+};

package/dist/libraries/react/{chunk-XTEUMENO.mjs → chunk-EOSHPHLH.mjs}

@@ -2,27 +2,14 @@
 
 import {
   AutumnClient
-} from "./chunk-XXOQMNM6.mjs";
+} from "./chunk-XDAZD5HF.mjs";
 
 // src/libraries/react/AutumnContext.tsx
 import { createContext, useContext } from "react";
 var AutumnContext = createContext({
-  customerProvider: null,
-  pricingTableProvider: {
-    pricingTableProducts: null,
-    isLoading: true,
-    error: null,
-    refetch: () => Promise.resolve()
-  },
-  entityProvider: {
-    entity: null,
-    isLoading: true,
-    error: null,
-    refetch: () => Promise.resolve(),
-    lastParams: null
-  },
+  initialized: false,
   client: new AutumnClient({
-    backendUrl: "http://localhost:8000"
+    backendUrl: process.env.NEXT_PUBLIC_AUTUMN_BACKEND_URL
   }),
   paywallDialog: {
     props: null,
@@ -45,12 +32,13 @@ var AutumnContext = createContext({
     }
   }
 });
-var useAutumnContext = () => {
-  const context = useContext(AutumnContext);
-  if (context === void 0) {
-    throw new Error(
-      "useAutumnContext must be used within a AutumnContextProvider"
-    );
+var useAutumnContext = ({
+  AutumnContext: AutumnContext2,
+  name
+}) => {
+  const context = useContext(AutumnContext2);
+  if (!context.initialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
   }
   return context;
 };

package/dist/libraries/react/chunk-IXVPNA4H.mjs

@@ -0,0 +1,20 @@
+"use client";
+
+import {
+  useCustomerBase
+} from "./chunk-A6J237PD.mjs";
+import {
+  AutumnContext
+} from "./chunk-EOSHPHLH.mjs";
+
+// src/libraries/react/hooks/useCustomer.tsx
+var useCustomer = (params) => {
+  return useCustomerBase({
+    params,
+    AutumnContext
+  });
+};
+
+export {
+  useCustomer
+};

package/dist/libraries/react/{chunk-OCZFV7OX.mjs → chunk-JNJ53ZW6.mjs}

@@ -2,7 +2,7 @@
 
 
 // src/sdk/error.ts
-var AutumnError = class extends Error {
+var AutumnError = class _AutumnError extends Error {
   message;
   code;
   constructor(response) {
@@ -10,6 +10,12 @@ var AutumnError = class extends Error {
     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})`;
   }
@@ -22,12 +28,14 @@ var AutumnError = class extends Error {
 };
 
 // src/sdk/response.ts
-var toContainerResult = async (response) => {
+var toContainerResult = async ({ response, logger: logger2 }) => {
   if (response.status < 200 || response.status >= 300) {
     let error;
     try {
       error = await response.json();
+      logger2.error(`[Autumn] ${error.message}`);
     } catch (error2) {
+      throw error2;
       return {
         data: null,
         error: new AutumnError({
@@ -54,6 +62,7 @@ var toContainerResult = async (response) => {
       statusCode: response?.status
     };
   } catch (error) {
+    throw error;
     return {
       data: null,
       error: new AutumnError({
@@ -65,6 +74,53 @@ var toContainerResult = async (response) => {
   }
 };
 
+// src/sdk/general/genMethods.ts
+var handleAttach = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/attach", params);
+};
+var handleCancel = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/cancel", params);
+};
+var handleEntitled = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/entitled", params);
+};
+var handleEvent = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/events", 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);
+};
+
+// src/libraries/backend/constants.ts
+var autumnApiUrl = "https://api.useautumn.com/v1";
+
 // src/sdk/utils.ts
 var staticWrapper = (callback, instance, args) => {
   if (!instance) {
@@ -177,50 +233,6 @@ var deleteEntity = async ({
   return instance.delete(`/customers/${customer_id}/entities/${entity_id}`);
 };
 
-// src/sdk/general/genMethods.ts
-var handleAttach = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/attach", params);
-};
-var handleCancel = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/cancel", params);
-};
-var handleEntitled = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/entitled", params);
-};
-var handleEvent = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/events", 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);
-};
-
 // src/sdk/products/prodMethods.ts
 var productMethods = (instance) => {
   return {
@@ -281,14 +293,52 @@ var redeemReferralCode = async ({
   return instance.post("/referrals/redeem", params);
 };
 
+// src/utils/logger.ts
+import chalk from "chalk";
+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(), chalk.gray("DEBUG"), ...args);
+    }
+  },
+  log: (...args) => {
+    console.log(getTime(), chalk.blue("INFO"), ...args);
+  },
+  info: (...args) => {
+    if (greaterThanLevel("info")) {
+      console.log(getTime(), chalk.blue("INFO"), ...args);
+    }
+  },
+  warn: (...args) => {
+    if (greaterThanLevel("warn")) {
+      console.log(getTime(), chalk.yellow("WARN"), ...args);
+    }
+  },
+  error: (...args) => {
+    if (greaterThanLevel("error")) {
+      console.log(getTime(), chalk.red("ERROR"), ...args);
+    }
+  }
+};
+
 // src/sdk/client.ts
 var LATEST_API_VERSION = "1.2";
 var Autumn = class {
   secretKey;
   publishableKey;
-  level;
   headers;
   url;
+  logger = console;
   constructor(options) {
     try {
       this.secretKey = options?.secretKey || process.env.AUTUMN_SECRET_KEY;
@@ -304,17 +354,15 @@ var Autumn = class {
     };
     let version = options?.version || LATEST_API_VERSION;
     this.headers["x-api-version"] = version;
-    this.url = options?.url || "https://api.useautumn.com/v1";
-    this.level = this.secretKey ? "secret" : "publishable";
-  }
-  getLevel() {
-    return this.level;
+    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);
+    return toContainerResult({ response, logger: this.logger });
   }
   async post(path, body) {
     try {
@@ -323,7 +371,7 @@ var Autumn = class {
         headers: this.headers,
         body: JSON.stringify(body)
       });
-      return toContainerResult(response);
+      return toContainerResult({ response, logger: this.logger });
     } catch (error) {
       console.error("Error sending request:", error);
       throw error;
@@ -334,7 +382,7 @@ var Autumn = class {
       method: "DELETE",
       headers: this.headers
     });
-    return toContainerResult(response);
+    return toContainerResult({ response, logger: this.logger });
   }
   static customers = customerMethods();
   static products = productMethods();