autumn-js 0.0.66 → 0.0.72

package/components.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/styles/global.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}

package/dist/libraries/backend/{chunk-NDN25XDG.mjs → chunk-2JZFMBVR.mjs}

@@ -1,6 +1,6 @@
 import {
   withAuth
-} from "./chunk-C2YFOJYP.mjs";
+} from "./chunk-ZF4V3SVZ.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";

package/dist/libraries/backend/chunk-45WVZY23.mjs

@@ -0,0 +1,41 @@
+// 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);
+    }
+  }
+};
+
+export {
+  logger
+};

package/dist/libraries/backend/{chunk-NDS3EHT3.mjs → chunk-GUZSIYGF.mjs}

@@ -1,6 +1,6 @@
 import {
   withAuth
-} from "./chunk-C2YFOJYP.mjs";
+} from "./chunk-ZF4V3SVZ.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";

package/dist/libraries/backend/{chunk-W63TY2DI.mjs → chunk-J7UA442M.mjs}

@@ -1,5 +1,12 @@
+import {
+  logger
+} from "./chunk-45WVZY23.mjs";
+import {
+  autumnApiUrl
+} from "./chunk-KSG3E4Q2.mjs";
+
 // src/sdk/error.ts
-var AutumnError = class extends Error {
+var AutumnError = class _AutumnError extends Error {
   message;
   code;
   constructor(response) {
@@ -7,6 +14,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})`;
   }
@@ -18,6 +31,50 @@ 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/sdk/utils.ts
 var staticWrapper = (callback, instance, args) => {
   if (!instance) {
@@ -130,50 +187,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 {
@@ -186,7 +199,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)) {
@@ -235,12 +248,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({
@@ -267,6 +282,7 @@ var toContainerResult = async (response) => {
       statusCode: response?.status
     };
   } catch (error) {
+    throw error;
     return {
       data: null,
       error: new AutumnError({
@@ -283,9 +299,9 @@ 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;
@@ -301,17 +317,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 {
@@ -320,7 +334,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;
@@ -331,7 +345,7 @@ var Autumn = class {
       method: "DELETE",
       headers: this.headers
     });
-    return toContainerResult(response);
+    return toContainerResult({ response, logger: this.logger });
   }
   static customers = customerMethods();
   static products = productMethods();
@@ -446,9 +460,6 @@ var toBackendError = ({
   code,
   statusCode = 500
 }) => {
-  console.error(
-    `Autumn middleware error: ${message} (code: ${code}) | path: ${path}`
-  );
   return {
     statusCode,
     body: new AutumnError({

package/dist/libraries/backend/chunk-PBBWXVWW.mjs

@@ -0,0 +1,28 @@
+import {
+  withAuth
+} from "./chunk-ZF4V3SVZ.mjs";
+import {
+  BASE_PATH
+} from "./chunk-KSG3E4Q2.mjs";
+
+// src/libraries/backend/routes/productRoutes.ts
+import { addRoute } from "rou3";
+var listProductsHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id
+  }) => {
+    return await autumn.products.list({
+      customer_id
+    });
+  }
+});
+var addProductRoutes = async (router) => {
+  addRoute(router, "GET", `${BASE_PATH}/products`, {
+    handler: listProductsHandler
+  });
+};
+
+export {
+  addProductRoutes
+};

package/dist/libraries/backend/{chunk-FRL4IWBU.mjs → chunk-T4YSUMNB.mjs}

@@ -1,18 +1,21 @@
 import {
   addEntityRoutes
-} from "./chunk-QXJ7YDTB.mjs";
+} from "./chunk-Y2VYFWJD.mjs";
 import {
   addGenRoutes
-} from "./chunk-NDN25XDG.mjs";
+} from "./chunk-2JZFMBVR.mjs";
+import {
+  addProductRoutes
+} from "./chunk-PBBWXVWW.mjs";
 import {
   addReferralRoutes
-} from "./chunk-NDS3EHT3.mjs";
+} from "./chunk-GUZSIYGF.mjs";
 import {
   withAuth
-} from "./chunk-C2YFOJYP.mjs";
+} from "./chunk-ZF4V3SVZ.mjs";
 import {
   fetchPricingTable
-} from "./chunk-W63TY2DI.mjs";
+} from "./chunk-J7UA442M.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";
@@ -67,6 +70,7 @@ var createRouterWithOptions = () => {
   addGenRoutes(router);
   addEntityRoutes(router);
   addReferralRoutes(router);
+  addProductRoutes(router);
   return router;
 };
 

package/dist/libraries/backend/chunk-UNZHJTEY.mjs

@@ -0,0 +1,18 @@
+// src/libraries/backend/utils/secretKeyCheck.ts
+var secretKeyCheck = (secretKey) => {
+  if (!secretKey && !process.env.AUTUMN_SECRET_KEY) {
+    return {
+      found: false,
+      error: {
+        statusCode: 500,
+        message: `Autumn secret key not found in ENV variables or passed into autumnHandler`,
+        code: "no_secret_key"
+      }
+    };
+  }
+  return { found: true, error: null };
+};
+
+export {
+  secretKeyCheck
+};

package/dist/libraries/backend/{chunk-QXJ7YDTB.mjs → chunk-Y2VYFWJD.mjs}

@@ -1,6 +1,6 @@
 import {
   withAuth
-} from "./chunk-C2YFOJYP.mjs";
+} from "./chunk-ZF4V3SVZ.mjs";
 
 // src/libraries/backend/routes/entityRoutes.ts
 import { addRoute } from "rou3";

package/dist/libraries/backend/{chunk-C2YFOJYP.mjs → chunk-ZF4V3SVZ.mjs}

@@ -1,7 +1,10 @@
 import {
   toBackendError,
   toBackendRes
-} from "./chunk-W63TY2DI.mjs";
+} from "./chunk-J7UA442M.mjs";
+import {
+  logger
+} from "./chunk-45WVZY23.mjs";
 
 // src/libraries/backend/utils/withAuth.ts
 var withAuth = ({
@@ -20,16 +23,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
         });
@@ -47,6 +51,7 @@ var withAuth = ({
       });
       return toBackendRes({ res });
     } catch (error) {
+      logger.error(`${error.message}`);
       return toBackendError({
         path,
         message: error.message || "unknown error",

package/dist/libraries/backend/express.d.mts

@@ -1,12 +1,13 @@
-import { A as Autumn } from './referralTypes-BdY-EkkQ.mjs';
+import { A as Autumn } from './referralTypes-C-jpvu6u.mjs';
 import { AuthResult } from './utils/AuthFunction.mjs';
-import './response-ByHPEnHs.mjs';
+import './response-CV6KGWH5.mjs';
 
 type AutumnRequestHandler = (req: any, res: any, next: any) => void;
 type AutumnHandlerOptions = {
     identify: (req: any) => AuthResult;
     autumn?: (req: any) => Autumn | Autumn;
     version?: string;
+    secretKey?: string;
 };
 declare const autumnHandler: (options?: AutumnHandlerOptions) => AutumnRequestHandler;
 

package/dist/libraries/backend/express.d.ts

@@ -1,12 +1,13 @@
-import { A as Autumn } from './referralTypes-p6A_PZbz.js';
+import { A as Autumn } from './referralTypes-qdpA4XBw.js';
 import { AuthResult } from './utils/AuthFunction.js';
-import './response-ByHPEnHs.js';
+import './response-CV6KGWH5.js';
 
 type AutumnRequestHandler = (req: any, res: any, next: any) => void;
 type AutumnHandlerOptions = {
     identify: (req: any) => AuthResult;
     autumn?: (req: any) => Autumn | Autumn;
     version?: string;
+    secretKey?: string;
 };
 declare const autumnHandler: (options?: AutumnHandlerOptions) => AutumnRequestHandler;