autumn-js 0.0.65 → 0.0.67

package/dist/libraries/react/hooks/{useEntityProvider.js → useCustomerBase.js}

@@ -1,9 +1,11 @@
 "use client";
 
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,18 +19,26 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/libraries/react/hooks/useEntityProvider.tsx
-var useEntityProvider_exports = {};
-__export(useEntityProvider_exports, {
-  useEntityProvider: () => useEntityProvider
+// src/libraries/react/hooks/useCustomerBase.tsx
+var useCustomerBase_exports = {};
+__export(useCustomerBase_exports, {
+  useCustomerBase: () => useCustomerBase
 });
-module.exports = __toCommonJS(useEntityProvider_exports);
-var import_react = require("react");
+module.exports = __toCommonJS(useCustomerBase_exports);
+var import_swr = __toESM(require("swr"));
 
 // src/sdk/error.ts
-var AutumnError = class extends Error {
+var AutumnError = class _AutumnError extends Error {
   message;
   code;
   constructor(response) {
@@ -36,6 +46,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})`;
   }
@@ -47,6 +63,53 @@ var AutumnError = class extends Error {
   }
 };
 
+// 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) {
@@ -159,50 +222,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 {
@@ -264,12 +283,14 @@ var redeemReferralCode = async ({
 };
 
 // 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({
@@ -296,6 +317,7 @@ var toContainerResult = async (response) => {
       statusCode: response?.status
     };
   } catch (error) {
+    throw error;
     return {
       data: null,
       error: new AutumnError({
@@ -307,14 +329,52 @@ var toContainerResult = async (response) => {
   }
 };
 
+// src/utils/logger.ts
+var import_chalk = __toESM(require("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(), import_chalk.default.gray("DEBUG"), ...args);
+    }
+  },
+  log: (...args) => {
+    console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+  },
+  info: (...args) => {
+    if (greaterThanLevel("info")) {
+      console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+    }
+  },
+  warn: (...args) => {
+    if (greaterThanLevel("warn")) {
+      console.log(getTime(), import_chalk.default.yellow("WARN"), ...args);
+    }
+  },
+  error: (...args) => {
+    if (greaterThanLevel("error")) {
+      console.log(getTime(), import_chalk.default.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;
@@ -330,17 +390,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 {
@@ -349,7 +407,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;
@@ -360,7 +418,7 @@ var Autumn = class {
       method: "DELETE",
       headers: this.headers
     });
-    return toContainerResult(response);
+    return toContainerResult({ response, logger: this.logger });
   }
   static customers = customerMethods();
   static products = productMethods();
@@ -437,44 +495,312 @@ var Autumn = class {
   }
 };
 
-// src/libraries/react/hooks/useEntityProvider.tsx
-var useEntityProvider = ({ client }) => {
-  const [entity, setEntity] = (0, import_react.useState)(null);
-  const [error, setError] = (0, import_react.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
-  const [lastParams, setLastParams] = (0, import_react.useState)(null);
-  const fetchEntity = async ({
-    entityId,
-    params
-  }) => {
-    if (!entityId) {
-      console.warn("(Autumn) No entity ID provided in useEntity hook");
-      return;
+// 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.`);
+};
+
+// src/libraries/react/client/clientCompMethods.ts
+async function getPricingTableMethod() {
+  const res = await this.get("/api/autumn/components/pricing_table");
+  return res;
+}
+
+// src/libraries/react/client/clientCusMethods.ts
+var createCustomerMethod = async ({
+  client,
+  params
+}) => {
+  let result = await client.post("/api/autumn/customers", params);
+  return result;
+};
+
+// 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) => {
+  if (Array.isArray(obj)) {
+    return obj.map(toSnakeCase);
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        stringToSnakeCase(key),
+        toSnakeCase(value)
+      ])
+    );
+  }
+  return obj;
+};
+
+// src/utils/entityUtils.tsx
+var getEntityExpandStr = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+
+// src/libraries/react/client/clientEntityMethods.ts
+async function createEntityMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post("/api/autumn/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}`);
+  return res;
+}
+async function deleteEntityMethod(entityId) {
+  const res = await this.delete(`/api/autumn/entities/${entityId}`);
+  return res;
+}
+
+// src/libraries/react/client/clientGenMethods.ts
+async function attachMethod(params) {
+  let { dialog, ...rest } = params;
+  let snakeParams = toSnakeCase(rest);
+  const res = await this.post("/api/autumn/attach", snakeParams);
+  return res;
+}
+async function cancelMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post("/api/autumn/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);
+  return res;
+}
+async function trackMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post("/api/autumn/track", snakeParams);
+  return res;
+}
+async function openBillingPortalMethod(params) {
+  let snakeParams = toSnakeCase(params || {});
+  const res = await this.post("/api/autumn/billing_portal", snakeParams);
+  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);
+  return res;
+}
+async function redeemCode(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post("/api/autumn/referrals/redeem", snakeParams);
+  return res;
+}
+
+// src/libraries/react/client/ReactAutumnClient.tsx
+var AutumnClient = class {
+  backendUrl;
+  getBearerToken;
+  customerData;
+  includeCredentials;
+  constructor({
+    backendUrl,
+    getBearerToken,
+    customerData,
+    includeCredentials
+  }) {
+    this.backendUrl = backendUrl;
+    this.getBearerToken = getBearerToken;
+    this.customerData = customerData;
+    this.includeCredentials = includeCredentials;
+  }
+  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`);
+      }
     }
-    setIsLoading(true);
-    setLastParams(params || null);
+    return headers;
+  }
+  async handleFetch({
+    path,
+    method,
+    body
+  }) {
+    body = method === "POST" ? JSON.stringify({
+      ...body,
+      customer_data: this.customerData || void 0
+    }) : void 0;
     try {
-      const { data, error: error2 } = await client.entities.get(entityId, params);
-      if (error2) {
-        setError(error2);
-        setEntity(null);
-      } else {
-        setEntity(data);
-        setError(null);
-      }
-    } catch (error2) {
-      setError(
-        new AutumnError({
-          message: error2?.message || "Failed to fetch entity",
-          code: "entity_fetch_failed"
+      const response = await fetch(`${this.backendUrl}${path}`, {
+        method,
+        body,
+        headers: await this.getHeaders(),
+        credentials: this.includeCredentials ? "include" : void 0
+      });
+      return await toContainerResult({ response, logger: console });
+    } catch (error) {
+      logFetchError({
+        method,
+        backendUrl: this.backendUrl || "",
+        path,
+        error
+      });
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "fetch_failed"
         })
-      );
+      };
     }
-    setIsLoading(false);
+  }
+  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);
+  cancel = cancelMethod.bind(this);
+  check = checkMethod.bind(this);
+  track = trackMethod.bind(this);
+  openBillingPortal = openBillingPortalMethod.bind(this);
+  entities = {
+    create: createEntityMethod.bind(this),
+    get: getEntityMethod.bind(this),
+    delete: deleteEntityMethod.bind(this)
+  };
+  referrals = {
+    createCode: createCode.bind(this),
+    redeemCode: redeemCode.bind(this)
+  };
+};
+
+// src/libraries/react/AutumnContext.tsx
+var import_react = require("react");
+var AutumnContext = (0, import_react.createContext)({
+  initialized: false,
+  client: new AutumnClient({
+    backendUrl: process.env.NEXT_PUBLIC_AUTUMN_BACKEND_URL
+  }),
+  paywallDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  },
+  prodChangeDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  }
+});
+var useAutumnContext = ({
+  AutumnContext: AutumnContext2,
+  name
+}) => {
+  const context = (0, import_react.useContext)(AutumnContext2);
+  if (!context.initialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
+  return context;
+};
+
+// src/libraries/react/hooks/useCustomerBase.tsx
+var useCustomerBase = ({
+  params,
+  AutumnContext: AutumnContext2,
+  client
+}) => {
+  const queryKey = ["customer"];
+  let context;
+  if (AutumnContext2) {
+    context = useAutumnContext({ AutumnContext: AutumnContext2, 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 } = (0, import_swr.default)(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
   };
-  return { entity, isLoading, error, refetch: fetchEntity, lastParams };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  useEntityProvider
+  useCustomerBase
 });

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

@@ -0,0 +1,18 @@
+"use client";
+
+import {
+  useCustomerBase
+} from "../chunk-A6J237PD.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";
+import "../chunk-TGX6UKKS.mjs";
+import "../chunk-4KKWHG2V.mjs";
+import "../chunk-ZNPQQ2WK.mjs";
+export {
+  useCustomerBase
+};

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

@@ -1,13 +1,13 @@
-import { A as AutumnError } from '../error-CG2LXoa7.mjs';
+import * as swr from 'swr';
 import { E as Entity } from '../entTypes-CV-165S-.mjs';
 import { GetEntityParams } from '../client/types/clientEntTypes.mjs';
 import '../cusTypes-Cf-s9PYP.mjs';
 
-declare const useEntity: (entityId: string, params?: GetEntityParams) => {
+declare const useEntity: (entityId: string | null, params?: GetEntityParams) => {
     entity: Entity | null;
     isLoading: boolean;
-    error: AutumnError | null;
-    refetch: (params: GetEntityParams) => Promise<void>;
+    error: any;
+    refetch: swr.KeyedMutator<Entity | null>;
 };
 
 export { useEntity };

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

@@ -1,13 +1,13 @@
-import { A as AutumnError } from '../error-CG2LXoa7.js';
+import * as swr from 'swr';
 import { E as Entity } from '../entTypes-BbIk0Toa.js';
 import { GetEntityParams } from '../client/types/clientEntTypes.js';
 import '../cusTypes-Cf-s9PYP.js';
 
-declare const useEntity: (entityId: string, params?: GetEntityParams) => {
+declare const useEntity: (entityId: string | null, params?: GetEntityParams) => {
     entity: Entity | null;
     isLoading: boolean;
-    error: AutumnError | null;
-    refetch: (params: GetEntityParams) => Promise<void>;
+    error: any;
+    refetch: swr.KeyedMutator<Entity | null>;
 };
 
 export { useEntity };