autumn-js 0.0.66 → 0.0.72

package/dist/libraries/backend/react-router.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ 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/backend/react-router.ts
@@ -23,10 +33,10 @@ __export(react_router_exports, {
   autumnHandler: () => autumnHandler
 });
 module.exports = __toCommonJS(react_router_exports);
-var import_rou35 = require("rou3");
+var import_rou36 = require("rou3");
 
 // src/sdk/error.ts
-var AutumnError = class extends Error {
+var AutumnError = class _AutumnError extends Error {
   message;
   code;
   constructor(response) {
@@ -34,6 +44,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})`;
   }
@@ -45,6 +61,54 @@ 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";
+var BASE_PATH = "/api/autumn";
+
 // src/sdk/utils.ts
 var staticWrapper = (callback, instance, args) => {
   if (!instance) {
@@ -157,50 +221,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 {
@@ -213,7 +233,7 @@ var listProducts = async ({
   instance,
   params
 }) => {
-  let path = "/products";
+  let path = "/products_beta";
   if (params) {
     const queryParams = new URLSearchParams();
     for (const [key, value] of Object.entries(params)) {
@@ -262,12 +282,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({
@@ -294,6 +316,7 @@ var toContainerResult = async (response) => {
       statusCode: response?.status
     };
   } catch (error) {
+    throw error;
     return {
       data: null,
       error: new AutumnError({
@@ -305,14 +328,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;
@@ -328,17 +389,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 {
@@ -347,7 +406,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;
@@ -358,7 +417,7 @@ var Autumn = class {
       method: "DELETE",
       headers: this.headers
     });
-    return toContainerResult(response);
+    return toContainerResult({ response, logger: this.logger });
   }
   static customers = customerMethods();
   static products = productMethods();
@@ -473,9 +532,6 @@ var toBackendError = ({
   code,
   statusCode = 500
 }) => {
-  console.error(
-    `Autumn middleware error: ${message} (code: ${code}) | path: ${path}`
-  );
   return {
     statusCode,
     body: new AutumnError({
@@ -502,16 +558,17 @@ var withAuth = ({
     let customerId = authResult?.customerId;
     if (!customerId && requireCustomer) {
       if (body?.errorOnNotFound === false) {
-        return toBackendError({
-          path,
-          message: "No customer ID found",
-          code: "no_customer_id",
-          statusCode: 202
-        });
+        return {
+          statusCode: 202,
+          body: null
+        };
       } else {
+        logger.error(
+          `[Autumn]: customerId returned from identify function is ${customerId}`
+        );
         return toBackendError({
           path,
-          message: "No customer ID found",
+          message: `customerId returned from identify function is ${customerId}`,
           code: "no_customer_id",
           statusCode: 401
         });
@@ -529,6 +586,7 @@ var withAuth = ({
       });
       return toBackendRes({ res });
     } catch (error) {
+      logger.error(`${error.message}`);
       return toBackendError({
         path,
         message: error.message || "unknown error",
@@ -540,12 +598,6 @@ var withAuth = ({
 
 // src/libraries/backend/routes/genRoutes.ts
 var import_rou3 = require("rou3");
-
-// src/libraries/backend/constants.ts
-var autumnApiUrl = "https://api.useautumn.com/v1";
-var BASE_PATH = "/api/autumn";
-
-// src/libraries/backend/routes/genRoutes.ts
 var sanitizeBody = (body) => {
   let bodyCopy = { ...body };
   delete bodyCopy.customer_id;
@@ -635,7 +687,7 @@ var addGenRoutes = (router) => {
 };
 
 // src/libraries/backend/routes/backendRouter.ts
-var import_rou34 = require("rou3");
+var import_rou35 = require("rou3");
 
 // src/libraries/backend/routes/entityRoutes.ts
 var import_rou32 = require("rou3");
@@ -740,6 +792,24 @@ var addReferralRoutes = async (router) => {
   });
 };
 
+// src/libraries/backend/routes/productRoutes.ts
+var import_rou34 = require("rou3");
+var listProductsHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id
+  }) => {
+    return await autumn.products.list({
+      customer_id
+    });
+  }
+});
+var addProductRoutes = async (router) => {
+  (0, import_rou34.addRoute)(router, "GET", `${BASE_PATH}/products`, {
+    handler: listProductsHandler
+  });
+};
+
 // src/libraries/backend/routes/backendRouter.ts
 var sanitizeCustomerBody = (body) => {
   let bodyCopy = { ...body };
@@ -778,17 +848,18 @@ var getPricingTableHandler = withAuth({
   requireCustomer: false
 });
 var createRouterWithOptions = () => {
-  const router = (0, import_rou34.createRouter)();
-  (0, import_rou34.addRoute)(router, "POST", `${BASE_PATH}/customers`, {
+  const router = (0, import_rou35.createRouter)();
+  (0, import_rou35.addRoute)(router, "POST", `${BASE_PATH}/customers`, {
     handler: createCustomerHandler
   });
-  (0, import_rou34.addRoute)(router, "GET", `${BASE_PATH}/components/pricing_table`, {
+  (0, import_rou35.addRoute)(router, "GET", `${BASE_PATH}/components/pricing_table`, {
     handler: getPricingTableHandler,
     requireCustomer: false
   });
   addGenRoutes(router);
   addEntityRoutes(router);
   addReferralRoutes(router);
+  addProductRoutes(router);
   return router;
 };
 
@@ -804,7 +875,7 @@ function autumnHandler(options) {
     const url = new URL(request.url);
     const searchParams = Object.fromEntries(url.searchParams);
     const pathname = url.pathname;
-    const match = (0, import_rou35.findRoute)(router, method, pathname);
+    const match = (0, import_rou36.findRoute)(router, method, pathname);
     if (!match) {
       throw new Response("Not found", { status: 404 });
     }

package/dist/libraries/backend/react-router.mjs

@@ -1,13 +1,15 @@
 import {
   createRouterWithOptions
-} from "./chunk-FRL4IWBU.mjs";
-import "./chunk-QXJ7YDTB.mjs";
-import "./chunk-NDN25XDG.mjs";
-import "./chunk-NDS3EHT3.mjs";
-import "./chunk-C2YFOJYP.mjs";
+} from "./chunk-T4YSUMNB.mjs";
+import "./chunk-Y2VYFWJD.mjs";
+import "./chunk-2JZFMBVR.mjs";
+import "./chunk-PBBWXVWW.mjs";
+import "./chunk-GUZSIYGF.mjs";
+import "./chunk-ZF4V3SVZ.mjs";
 import {
   Autumn
-} from "./chunk-W63TY2DI.mjs";
+} from "./chunk-J7UA442M.mjs";
+import "./chunk-45WVZY23.mjs";
 import {
   autumnApiUrl
 } from "./chunk-KSG3E4Q2.mjs";

package/dist/libraries/backend/{referralTypes-p6A_PZbz.d.ts → referralTypes-C-jpvu6u.d.mts}

@@ -1,4 +1,4 @@
-import { R as Result, A as AutumnError } from './response-ByHPEnHs.js';
+import { R as Result, A as AutumnError } from './response-CV6KGWH5.mjs';
 
 declare enum AppEnv {
     Sandbox = "sandbox",
@@ -36,15 +36,14 @@ declare enum ProductStatus {
 }
 type CustomerExpandOption = "invoices" | "rewards" | "trials_used" | "entities";
 
-interface CustomerFeature {
-    id: string;
-    name: string;
+interface CoreCustomerFeature {
     unlimited?: boolean;
     interval?: ProductItemInterval | null;
     balance?: number;
     usage?: number;
     included_usage?: number;
     next_reset_at?: number | null;
+    overage_allowed?: boolean;
     breakdown?: {
         interval: ProductItemInterval;
         balance?: number;
@@ -52,6 +51,15 @@ interface CustomerFeature {
         included_usage?: number;
         next_reset_at?: number;
     }[];
+    credit_schema?: {
+        feature_id: string;
+        credit_amount: number;
+    }[];
+}
+interface CustomerFeature extends CoreCustomerFeature {
+    id: string;
+    name: string;
+    type: "static" | "single_use" | "continuous_use";
 }
 interface CustomerProduct {
     id: string;
@@ -106,10 +114,6 @@ interface UpdateCustomerParams {
 interface BillingPortalParams {
     return_url?: string;
 }
-interface BillingPortalResponse {
-    customer_id: string;
-    url: string;
-}
 interface CustomerInvoice {
     product_ids: string[];
     stripe_id: string;
@@ -161,16 +165,20 @@ interface ProductItem {
     entity_feature_id?: string;
     reset_usage_on_billing?: boolean;
     reset_usage_when_enabled?: boolean;
+    display?: {
+        primary_text?: string;
+        secondary_text?: string;
+    };
 }
 interface FreeTrial {
     duration: FreeTrialDuration;
     length: number;
     unique_fingerprint: boolean;
+    trial_available?: boolean;
 }
 interface Product {
-    autumn_id: string;
-    created_at: number;
     id: string;
+    created_at: number;
     name: string;
     env: AppEnv;
     is_add_on: boolean;
@@ -179,6 +187,19 @@ interface Product {
     version: number;
     items: ProductItem[];
     free_trial: FreeTrial | null;
+    scenario?: ProductScenario;
+    properties?: {
+        is_free?: boolean;
+        is_one_off?: boolean;
+        interval_group?: string;
+    };
+    display?: {
+        description?: string;
+        button_text?: string;
+        recommend_text?: string;
+        everything_from?: string;
+        button_url?: string;
+    };
 }
 interface CreateProductParams {
     id: string;
@@ -189,10 +210,20 @@ interface CreateProductParams {
     free_trial?: FreeTrial;
 }
 interface ListProductsParams {
+    customer_id?: string;
 }
 
 type CheckFeatureScenario = "usage_limit" | "feature_flag";
-interface CheckFeatureFormattedPreview {
+interface CheckFeatureResult extends CoreCustomerFeature {
+    allowed: boolean;
+    feature_id: string;
+    customer_id: string;
+    entity_id?: string;
+    required_balance: number;
+    code: string;
+    preview?: CheckFeaturePreview;
+}
+interface CheckFeaturePreview {
     scenario: CheckFeatureScenario;
     title: string;
     message: string;
@@ -200,9 +231,17 @@ interface CheckFeatureFormattedPreview {
     feature_name: string;
     products: Product[];
 }
-type CheckProductScenario = "scheduled" | "active" | "new" | "renew" | "upgrade" | "downgrade" | "cancel";
-interface CheckProductFormattedPreview {
-    scenario: CheckProductScenario;
+type ProductScenario = "scheduled" | "active" | "new" | "renew" | "upgrade" | "downgrade" | "cancel";
+interface CheckProductResult {
+    allowed: boolean;
+    customer_id: string;
+    product_id: string;
+    code: string;
+    status?: string;
+    preview?: CheckProductPreview;
+}
+interface CheckProductPreview {
+    scenario: ProductScenario;
     product_id: string;
     product_name: string;
     recurring: boolean;
@@ -297,21 +336,10 @@ interface CheckParams {
     customer_data?: CustomerData;
     required_balance?: number;
     send_event?: boolean;
-    with_preview?: "raw" | "formatted";
+    with_preview?: boolean;
     entity_data?: EntityData;
 }
-interface CheckResult {
-    customer_id: string;
-    allowed: boolean;
-    code: string;
-    feature_id?: string;
-    required_balance?: number;
-    unlimited?: boolean;
-    balance?: number | null;
-    product_id?: string;
-    status?: string;
-    preview?: CheckProductFormattedPreview | CheckFeatureFormattedPreview;
-}
+type CheckResult = CheckFeatureResult & CheckProductResult;
 interface UsageParams {
     customer_id: string;
     feature_id: string;
@@ -327,17 +355,17 @@ interface UsageResult {
 declare class Autumn {
     private readonly secretKey;
     private readonly publishableKey;
-    private level;
     private headers;
     private url;
+    private logger;
     constructor(options?: {
         secretKey?: string;
         publishableKey?: string;
         url?: string;
         version?: string;
         headers?: Record<string, string>;
+        logLevel?: string;
     });
-    getLevel(): "secret" | "publishable";
     get(path: string): Promise<Result<any, AutumnError>>;
     post(path: string, body: any): Promise<Result<any, AutumnError>>;
     delete(path: string): Promise<Result<any, AutumnError>>;
@@ -351,7 +379,9 @@ declare class Autumn {
     static products: {
         get: (id: string) => Promise<Result<Product, AutumnError>>;
         create: (params?: CreateProductParams) => Promise<Result<Product, AutumnError>>;
-        list: (params?: ListProductsParams) => Promise<Result<Product[], AutumnError>>;
+        list: (params?: ListProductsParams) => Promise<Result<{
+            list: Product[];
+        }, AutumnError>>;
     };
     static entities: {
         get: (customer_id: string, entity_id: string, params?: GetEntityParams) => Promise<Result<Entity, AutumnError>>;
@@ -372,7 +402,9 @@ declare class Autumn {
     products: {
         get: (id: string) => Promise<Result<Product, AutumnError>>;
         create: (params?: CreateProductParams) => Promise<Result<Product, AutumnError>>;
-        list: (params?: ListProductsParams) => Promise<Result<Product[], AutumnError>>;
+        list: (params?: ListProductsParams) => Promise<Result<{
+            list: Product[];
+        }, AutumnError>>;
     };
     entities: {
         get: (customer_id: string, entity_id: string, params?: GetEntityParams) => Promise<Result<Entity, AutumnError>>;