autumn-js 0.0.36 → 0.0.41

package/dist/libraries/backend/{chunk-4ZZPTUK5.mjs → chunk-7SOQYC4B.mjs}

@@ -109,11 +109,12 @@ var getEntity = async ({
   entity_id,
   params
 }) => {
-  return instance.get(
+  let res = instance.get(
     `/customers/${customer_id}/entities/${entity_id}?${getExpandStr2(
       params?.expand
     )}`
   );
+  return res;
 };
 var createEntity = async ({
   instance,
@@ -240,8 +241,9 @@ var toContainerResult = async (response) => {
     };
   }
   try {
+    let data = await response.json();
     return {
-      data: await response.json(),
+      data,
       error: null,
       statusCode: response?.status
     };
@@ -267,8 +269,8 @@ var Autumn = class {
   url;
   constructor(options) {
     try {
-      this.secretKey = options.secretKey || process.env.AUTUMN_SECRET_KEY;
-      this.publishableKey = options.publishableKey || process.env.AUTUMN_PUBLISHABLE_KEY;
+      this.secretKey = options?.secretKey || process.env.AUTUMN_SECRET_KEY;
+      this.publishableKey = options?.publishableKey || process.env.AUTUMN_PUBLISHABLE_KEY;
     } catch (error) {
     }
     if (!this.secretKey && !this.publishableKey) {
@@ -278,9 +280,9 @@ var Autumn = class {
       Authorization: `Bearer ${this.secretKey || this.publishableKey}`,
       "Content-Type": "application/json"
     };
-    let version = options.version || LATEST_API_VERSION;
+    let version = options?.version || LATEST_API_VERSION;
     this.headers["x-api-version"] = version;
-    this.url = options.url || "https://api.useautumn.com/v1";
+    this.url = options?.url || "https://api.useautumn.com/v1";
     this.level = this.secretKey ? "secret" : "publishable";
   }
   getLevel() {

package/dist/libraries/backend/{chunk-474B3AJB.mjs → chunk-GA6SKSWH.mjs}

@@ -1,12 +1,15 @@
+import {
+  addEntityRoutes
+} from "./chunk-XPNATE4H.mjs";
 import {
   addGenRoutes
-} from "./chunk-QQM3YBRM.mjs";
+} from "./chunk-UD4U5ECV.mjs";
 import {
   withAuth
-} from "./chunk-2BGK5SYQ.mjs";
+} from "./chunk-V7VIK7Q2.mjs";
 import {
   fetchPricingTable
-} from "./chunk-4ZZPTUK5.mjs";
+} from "./chunk-7SOQYC4B.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";
@@ -27,6 +30,7 @@ var createCustomerHandler = withAuth({
     customer_data = {},
     body
   }) => {
+    console.log;
     let res = await autumn.customers.create({
       id: customer_id,
       ...customer_data,
@@ -59,6 +63,7 @@ var createRouterWithOptions = ({ autumn }) => {
     requireCustomer: false
   });
   addGenRoutes(router);
+  addEntityRoutes(router);
   return router;
 };
 

package/dist/libraries/backend/{chunk-QQM3YBRM.mjs → chunk-UD4U5ECV.mjs}

@@ -1,6 +1,6 @@
 import {
   withAuth
-} from "./chunk-2BGK5SYQ.mjs";
+} from "./chunk-V7VIK7Q2.mjs";
 import {
   BASE_PATH
 } from "./chunk-KSG3E4Q2.mjs";
@@ -89,7 +89,7 @@ var addGenRoutes = (router) => {
   addRoute(router, "POST", `${BASE_PATH}/track`, {
     handler: trackHandler
   });
-  addRoute(router, "POST", `${BASE_PATH}/openBillingPortal`, {
+  addRoute(router, "POST", `${BASE_PATH}/billing_portal`, {
     handler: openBillingPortalHandler
   });
 };

package/dist/libraries/backend/{chunk-KCSLID2B.mjs → chunk-V7VIK7Q2.mjs}

@@ -1,7 +1,7 @@
 import {
   toBackendError,
   toBackendRes
-} from "./chunk-CVW7ZXDT.mjs";
+} from "./chunk-7SOQYC4B.mjs";
 
 // src/libraries/backend/utils/withAuth.ts
 var withAuth = ({
@@ -12,7 +12,9 @@ var withAuth = ({
     autumn,
     body,
     path,
-    getCustomer
+    getCustomer,
+    pathParams,
+    searchParams
   }) => {
     let authResult = await getCustomer();
     if (!authResult && requireCustomer) {
@@ -38,7 +40,9 @@ var withAuth = ({
         body,
         autumn,
         customer_id: authResult?.customerId || "",
-        customer_data: cusData
+        customer_data: cusData,
+        pathParams,
+        searchParams
       });
       return toBackendRes({ res });
     } catch (error) {

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

@@ -0,0 +1,75 @@
+import {
+  withAuth
+} from "./chunk-V7VIK7Q2.mjs";
+
+// src/libraries/backend/routes/entityRoutes.ts
+import { addRoute } from "rou3";
+var createEntityHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    body
+  }) => {
+    return await autumn.entities.create(customer_id, body);
+  }
+});
+var getEntityHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    pathParams,
+    searchParams
+  }) => {
+    if (!pathParams?.entityId) {
+      return {
+        statusCode: 400,
+        body: {
+          error: "no_entity_id",
+          message: "Entity ID is required"
+        }
+      };
+    }
+    let params = {
+      expand: searchParams?.expand?.split(",")
+    };
+    let res = await autumn.entities.get(
+      customer_id,
+      pathParams.entityId,
+      params
+    );
+    return res;
+  }
+});
+var deleteEntityHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    pathParams
+  }) => {
+    if (!pathParams?.entityId) {
+      return {
+        statusCode: 400,
+        body: {
+          error: "no_entity_id",
+          message: "Entity ID is required"
+        }
+      };
+    }
+    return await autumn.entities.delete(customer_id, pathParams.entityId);
+  }
+});
+var addEntityRoutes = async (router) => {
+  addRoute(router, "POST", "/api/autumn/entities", {
+    handler: createEntityHandler
+  });
+  addRoute(router, "GET", "/api/autumn/entities/:entityId", {
+    handler: getEntityHandler
+  });
+  addRoute(router, "DELETE", "/api/autumn/entities/:entityId", {
+    handler: deleteEntityHandler
+  });
+};
+
+export {
+  addEntityRoutes
+};

package/dist/libraries/backend/{entTypes-CldG3gzH.d.mts → entTypes-BHLroNdS.d.mts}

@@ -71,6 +71,7 @@ interface Customer {
     fingerprint: string | null;
     stripe_id: string | null;
     env: AppEnv;
+    metadata: Record<string, any>;
     products: CustomerProduct[];
     features: Record<string, CustomerFeature>;
     invoices?: CustomerInvoice[];
@@ -88,6 +89,7 @@ interface CreateCustomerParams {
     email?: string | null;
     name?: string | null;
     fingerprint?: string | null;
+    metadata?: Record<string, any>;
     expand?: CustomerExpandOption[];
 }
 interface UpdateCustomerParams {

package/dist/libraries/backend/{entTypes-jaWNbRIx.d.ts → entTypes-BJGM9Knl.d.ts}

@@ -71,6 +71,7 @@ interface Customer {
     fingerprint: string | null;
     stripe_id: string | null;
     env: AppEnv;
+    metadata: Record<string, any>;
     products: CustomerProduct[];
     features: Record<string, CustomerFeature>;
     invoices?: CustomerInvoice[];
@@ -88,6 +89,7 @@ interface CreateCustomerParams {
     email?: string | null;
     name?: string | null;
     fingerprint?: string | null;
+    metadata?: Record<string, any>;
     expand?: CustomerExpandOption[];
 }
 interface UpdateCustomerParams {

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

@@ -0,0 +1,10 @@
+import { AuthResult } from './utils/AuthFunction.mjs';
+
+type AutumnRequestHandler = (req: any, res: any, next: any) => void;
+type AutumnHandlerOptions = {
+    identify: (req: any) => AuthResult;
+    version?: string;
+};
+declare const autumnHandler: (options?: AutumnHandlerOptions) => AutumnRequestHandler;
+
+export { type AutumnHandlerOptions, type AutumnRequestHandler, autumnHandler };

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

@@ -0,0 +1,10 @@
+import { AuthResult } from './utils/AuthFunction.js';
+
+type AutumnRequestHandler = (req: any, res: any, next: any) => void;
+type AutumnHandlerOptions = {
+    identify: (req: any) => AuthResult;
+    version?: string;
+};
+declare const autumnHandler: (options?: AutumnHandlerOptions) => AutumnRequestHandler;
+
+export { type AutumnHandlerOptions, type AutumnRequestHandler, autumnHandler };

package/dist/libraries/backend/{chunk-4BNMJOKS.mjs → express.js}

@@ -1,17 +1,11 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -21,14 +15,15 @@ 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/express.ts
+var express_exports = {};
+__export(express_exports, {
+  autumnHandler: () => autumnHandler
+});
+module.exports = __toCommonJS(express_exports);
+var import_rou34 = require("rou3");
 
 // src/sdk/error.ts
 var AutumnError = class extends Error {
@@ -141,11 +136,12 @@ var getEntity = async ({
   entity_id,
   params
 }) => {
-  return instance.get(
+  let res = instance.get(
     `/customers/${customer_id}/entities/${entity_id}?${getExpandStr2(
       params?.expand
     )}`
   );
+  return res;
 };
 var createEntity = async ({
   instance,
@@ -272,8 +268,9 @@ var toContainerResult = async (response) => {
     };
   }
   try {
+    let data = await response.json();
     return {
-      data: await response.json(),
+      data,
       error: null,
       statusCode: response?.status
     };
@@ -299,8 +296,8 @@ var Autumn = class {
   url;
   constructor(options) {
     try {
-      this.secretKey = options.secretKey || process.env.AUTUMN_SECRET_KEY;
-      this.publishableKey = options.publishableKey || process.env.AUTUMN_PUBLISHABLE_KEY;
+      this.secretKey = options?.secretKey || process.env.AUTUMN_SECRET_KEY;
+      this.publishableKey = options?.publishableKey || process.env.AUTUMN_PUBLISHABLE_KEY;
     } catch (error) {
     }
     if (!this.secretKey && !this.publishableKey) {
@@ -310,9 +307,9 @@ var Autumn = class {
       Authorization: `Bearer ${this.secretKey || this.publishableKey}`,
       "Content-Type": "application/json"
     };
-    let version = options.version || LATEST_API_VERSION;
-    this.headers["x-api-version"] = options.version;
-    this.url = options.url || "https://api.useautumn.com/v1";
+    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() {
@@ -462,12 +459,323 @@ var toBackendError = ({
   };
 };
 
-export {
-  __require,
-  __commonJS,
-  __toESM,
-  Autumn,
-  fetchPricingTable,
-  toBackendRes,
-  toBackendError
+// src/libraries/backend/utils/withAuth.ts
+var withAuth = ({
+  fn,
+  requireCustomer = true
+}) => {
+  return async ({
+    autumn,
+    body,
+    path,
+    getCustomer: getCustomer2,
+    pathParams,
+    searchParams
+  }) => {
+    let authResult = await getCustomer2();
+    if (!authResult && requireCustomer) {
+      if (body?.errorOnNotFound === false) {
+        return toBackendError({
+          path,
+          message: "No customer ID found",
+          code: "no_customer_id",
+          statusCode: 202
+        });
+      } else {
+        return toBackendError({
+          path,
+          message: "No customer ID found",
+          code: "no_customer_id",
+          statusCode: 401
+        });
+      }
+    }
+    let cusData = authResult?.customerData || body?.customer_data;
+    try {
+      let res = await fn({
+        body,
+        autumn,
+        customer_id: authResult?.customerId || "",
+        customer_data: cusData,
+        pathParams,
+        searchParams
+      });
+      return toBackendRes({ res });
+    } catch (error) {
+      return toBackendError({
+        path,
+        message: error.message || "unknown error",
+        code: "internal_error"
+      });
+    }
+  };
+};
+
+// 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;
+  delete bodyCopy.customer_data;
+  return bodyCopy;
+};
+var attachHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    customer_data,
+    body
+  }) => {
+    return await autumn.attach({
+      ...sanitizeBody(body),
+      customer_id,
+      customer_data
+    });
+  }
+});
+var cancelHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    body
+  }) => {
+    return await autumn.cancel({
+      ...sanitizeBody(body),
+      customer_id
+    });
+  }
+});
+var checkHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    customer_data,
+    body
+  }) => {
+    return await autumn.check({
+      ...sanitizeBody(body),
+      customer_id,
+      customer_data
+    });
+  }
+});
+var trackHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    customer_data,
+    body
+  }) => {
+    return await autumn.track({
+      ...sanitizeBody(body),
+      customer_id,
+      customer_data
+    });
+  }
+});
+var openBillingPortalHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    body
+  }) => {
+    return await autumn.customers.billingPortal(customer_id, body);
+  }
+});
+var addGenRoutes = (router) => {
+  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/attach`, {
+    handler: attachHandler
+  });
+  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/cancel`, {
+    handler: cancelHandler
+  });
+  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/check`, {
+    handler: checkHandler
+  });
+  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/track`, {
+    handler: trackHandler
+  });
+  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/billing_portal`, {
+    handler: openBillingPortalHandler
+  });
+};
+
+// src/libraries/backend/routes/backendRouter.ts
+var import_rou33 = require("rou3");
+
+// src/libraries/backend/routes/entityRoutes.ts
+var import_rou32 = require("rou3");
+var createEntityHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    body
+  }) => {
+    return await autumn.entities.create(customer_id, body);
+  }
+});
+var getEntityHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    pathParams,
+    searchParams
+  }) => {
+    if (!pathParams?.entityId) {
+      return {
+        statusCode: 400,
+        body: {
+          error: "no_entity_id",
+          message: "Entity ID is required"
+        }
+      };
+    }
+    let params = {
+      expand: searchParams?.expand?.split(",")
+    };
+    let res = await autumn.entities.get(
+      customer_id,
+      pathParams.entityId,
+      params
+    );
+    return res;
+  }
+});
+var deleteEntityHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    pathParams
+  }) => {
+    if (!pathParams?.entityId) {
+      return {
+        statusCode: 400,
+        body: {
+          error: "no_entity_id",
+          message: "Entity ID is required"
+        }
+      };
+    }
+    return await autumn.entities.delete(customer_id, pathParams.entityId);
+  }
+});
+var addEntityRoutes = async (router) => {
+  (0, import_rou32.addRoute)(router, "POST", "/api/autumn/entities", {
+    handler: createEntityHandler
+  });
+  (0, import_rou32.addRoute)(router, "GET", "/api/autumn/entities/:entityId", {
+    handler: getEntityHandler
+  });
+  (0, import_rou32.addRoute)(router, "DELETE", "/api/autumn/entities/:entityId", {
+    handler: deleteEntityHandler
+  });
 };
+
+// src/libraries/backend/routes/backendRouter.ts
+var sanitizeCustomerBody = (body) => {
+  let bodyCopy = { ...body };
+  delete bodyCopy.id;
+  delete bodyCopy.name;
+  delete bodyCopy.email;
+  return bodyCopy;
+};
+var createCustomerHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    customer_data = {},
+    body
+  }) => {
+    console.log;
+    let res = await autumn.customers.create({
+      id: customer_id,
+      ...customer_data,
+      ...sanitizeCustomerBody(body)
+    });
+    return res;
+  }
+});
+var getPricingTableHandler = withAuth({
+  fn: async ({
+    autumn,
+    customer_id
+  }) => {
+    return await fetchPricingTable({
+      instance: autumn,
+      params: {
+        customer_id: customer_id || void 0
+      }
+    });
+  },
+  requireCustomer: false
+});
+var createRouterWithOptions = ({ autumn }) => {
+  const router = (0, import_rou33.createRouter)();
+  (0, import_rou33.addRoute)(router, "POST", `${BASE_PATH}/customers`, {
+    handler: createCustomerHandler
+  });
+  (0, import_rou33.addRoute)(router, "GET", `${BASE_PATH}/components/pricing_table`, {
+    handler: getPricingTableHandler,
+    requireCustomer: false
+  });
+  addGenRoutes(router);
+  addEntityRoutes(router);
+  return router;
+};
+
+// src/libraries/backend/express.ts
+var autumnHandler = (options) => {
+  const autumn = new Autumn({
+    url: autumnApiUrl,
+    version: options?.version
+  });
+  const router = createRouterWithOptions({
+    autumn
+  });
+  return async (req, res, next) => {
+    let path = req.path;
+    const searchParams = Object.fromEntries(new URLSearchParams(req.query));
+    if (!path.startsWith("/api/autumn")) {
+      path = "/api/autumn" + path;
+    }
+    const match = (0, import_rou34.findRoute)(router, req.method, path);
+    if (match) {
+      const { data, params: pathParams } = match;
+      const { handler } = data;
+      let body = null;
+      if (req.method === "POST") {
+        try {
+          body = req.body;
+        } catch (error) {
+        }
+      }
+      try {
+        let result = await handler({
+          autumn,
+          body,
+          path: req.path,
+          getCustomer: async () => {
+            return await options?.identify(req);
+          },
+          pathParams,
+          searchParams
+        });
+        return res.status(result.statusCode).json(result.body);
+      } catch (error) {
+        console.error("Error handling Autumn request:", error);
+        return res.status(500).json({ error: "Internal server error" });
+      }
+    }
+    next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autumnHandler
+});