autumn-js 0.0.34 → 0.0.41

package/dist/libraries/backend/chunk-6DZX6EAA.mjs

@@ -0,0 +1,37 @@
+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 __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 __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/libraries/backend/chunk-7SOQYC4B.mjs

@@ -0,0 +1,440 @@
+// src/sdk/error.ts
+var AutumnError = class extends Error {
+  message;
+  code;
+  constructor(response) {
+    super(response.message);
+    this.message = response.message;
+    this.code = response.code;
+  }
+  toString() {
+    return `${this.message} (code: ${this.code})`;
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      code: this.code
+    };
+  }
+};
+
+// src/sdk/utils.ts
+var staticWrapper = (callback, instance, args) => {
+  if (!instance) {
+    instance = new Autumn();
+  }
+  return callback({ instance, ...args });
+};
+
+// src/sdk/customers/cusMethods.ts
+var customerMethods = (instance) => {
+  return {
+    get: (id, params) => staticWrapper(getCustomer, instance, { id, params }),
+    create: (params) => staticWrapper(createCustomer, instance, { params }),
+    update: (id, params) => staticWrapper(updateCustomer, instance, { id, params }),
+    delete: (id) => staticWrapper(deleteCustomer, instance, { id }),
+    billingPortal: (id, params) => staticWrapper(billingPortal, instance, { id, params })
+  };
+};
+var getExpandStr = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+var getCustomer = async ({
+  instance,
+  id,
+  params
+}) => {
+  if (!id) {
+    return {
+      data: null,
+      error: new AutumnError({
+        message: "Customer ID is required",
+        code: "CUSTOMER_ID_REQUIRED"
+      })
+    };
+  }
+  return instance.get(`/customers/${id}?${getExpandStr(params?.expand)}`);
+};
+var createCustomer = async ({
+  instance,
+  params
+}) => {
+  return instance.post(`/customers?${getExpandStr(params?.expand)}`, params);
+};
+var updateCustomer = async ({
+  instance,
+  id,
+  params
+}) => {
+  return instance.post(`/customers/${id}`, params);
+};
+var deleteCustomer = async ({
+  instance,
+  id
+}) => {
+  return instance.delete(`/customers/${id}`);
+};
+var billingPortal = async ({
+  instance,
+  id,
+  params
+}) => {
+  return instance.post(`/customers/${id}/billing_portal`, params);
+};
+
+// src/sdk/customers/entities/entMethods.ts
+var entityMethods = (instance) => {
+  return {
+    get: (customer_id, entity_id, params) => staticWrapper(getEntity, instance, {
+      customer_id,
+      entity_id,
+      params
+    }),
+    create: (customer_id, params) => staticWrapper(createEntity, instance, { customer_id, params }),
+    delete: (customer_id, entity_id) => staticWrapper(deleteEntity, instance, { customer_id, entity_id })
+  };
+};
+var getExpandStr2 = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+var getEntity = async ({
+  instance,
+  customer_id,
+  entity_id,
+  params
+}) => {
+  let res = instance.get(
+    `/customers/${customer_id}/entities/${entity_id}?${getExpandStr2(
+      params?.expand
+    )}`
+  );
+  return res;
+};
+var createEntity = async ({
+  instance,
+  customer_id,
+  params
+}) => {
+  return instance.post(`/customers/${customer_id}/entities`, params);
+};
+var deleteEntity = async ({
+  instance,
+  customer_id,
+  entity_id
+}) => {
+  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 {
+    get: (id) => staticWrapper(getProduct, instance, { id }),
+    create: (params) => staticWrapper(createProduct, instance, { params }),
+    list: (params) => staticWrapper(listProducts, instance, { params })
+  };
+};
+var listProducts = async ({
+  instance,
+  params
+}) => {
+  let path = "/products";
+  if (params) {
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        queryParams.append(key, String(value));
+      }
+    }
+    const queryString = queryParams.toString();
+    if (queryString) {
+      path += `?${queryString}`;
+    }
+  }
+  return instance.get(path);
+};
+var getProduct = async ({
+  instance,
+  id
+}) => {
+  return instance.get(`/products/${id}`);
+};
+var createProduct = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/products", params);
+};
+
+// src/sdk/response.ts
+var toContainerResult = async (response) => {
+  if (response.status < 200 || response.status >= 300) {
+    let error;
+    try {
+      error = await response.json();
+    } catch (error2) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: "Failed to parse JSON response from Autumn",
+          code: "internal_error"
+        }),
+        statusCode: response.status
+      };
+    }
+    return {
+      data: null,
+      error: new AutumnError({
+        message: error.message,
+        code: error.code
+      }),
+      statusCode: response.status
+    };
+  }
+  try {
+    let data = await response.json();
+    return {
+      data,
+      error: null,
+      statusCode: response?.status
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: new AutumnError({
+        message: "Failed to parse Autumn API response",
+        code: "internal_error"
+      }),
+      statusCode: response?.status
+    };
+  }
+};
+
+// src/sdk/client.ts
+var LATEST_API_VERSION = "1.2";
+var Autumn = class {
+  secretKey;
+  publishableKey;
+  level;
+  headers;
+  url;
+  constructor(options) {
+    try {
+      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) {
+      throw new Error("Autumn secret key or publishable key is required");
+    }
+    this.headers = {
+      Authorization: `Bearer ${this.secretKey || this.publishableKey}`,
+      "Content-Type": "application/json"
+    };
+    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;
+  }
+  async get(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      headers: this.headers
+    });
+    return toContainerResult(response);
+  }
+  async post(path, body) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    return toContainerResult(response);
+  }
+  async delete(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    return toContainerResult(response);
+  }
+  static customers = customerMethods();
+  static products = productMethods();
+  static entities = entityMethods();
+  customers = customerMethods(this);
+  products = productMethods(this);
+  entities = entityMethods(this);
+  static attach = (params) => staticWrapper(handleAttach, void 0, { params });
+  static usage = (params) => staticWrapper(handleUsage, void 0, { params });
+  async attach(params) {
+    return handleAttach({
+      instance: this,
+      params
+    });
+  }
+  static cancel = (params) => staticWrapper(handleCancel, void 0, { params });
+  async cancel(params) {
+    return handleCancel({
+      instance: this,
+      params
+    });
+  }
+  /**
+   * @deprecated This method is deprecated and will be removed in a future version.
+   * Please use the new check() method instead.
+   */
+  static entitled = (params) => staticWrapper(handleEntitled, void 0, { params });
+  /**
+   * @deprecated This method is deprecated and will be removed in a future version.
+   * Please use the new check() method instead.
+   */
+  async entitled(params) {
+    return handleEntitled({
+      instance: this,
+      params
+    });
+  }
+  static check = (params) => staticWrapper(handleCheck, void 0, { params });
+  async check(params) {
+    return handleCheck({
+      instance: this,
+      params
+    });
+  }
+  /**
+   * @deprecated This method is deprecated and will be removed in a future version.
+   * Please use the new track() method instead.
+   */
+  static event = (params) => staticWrapper(handleEvent, void 0, { params });
+  /**
+   * @deprecated This method is deprecated and will be removed in a future version.
+   * Please use the new track() method instead.
+   */
+  async event(params) {
+    return handleEvent({
+      instance: this,
+      params
+    });
+  }
+  static track = (params) => staticWrapper(handleTrack, void 0, { params });
+  async track(params) {
+    return handleTrack({
+      instance: this,
+      params
+    });
+  }
+  async usage(params) {
+    return handleUsage({
+      instance: this,
+      params
+    });
+  }
+};
+
+// src/sdk/components/componentMethods.ts
+var fetchPricingTable = async ({
+  instance,
+  params
+}) => {
+  let path = "/components/pricing_table";
+  if (params) {
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (key === "products") {
+        continue;
+      }
+      if (value !== void 0) {
+        queryParams.append(key, String(value));
+      }
+    }
+    const queryString = queryParams.toString();
+    if (queryString) {
+      path += `?${queryString}`;
+    }
+  }
+  return await instance.get(path);
+};
+
+// src/libraries/backend/utils/backendRes.ts
+var toBackendRes = ({ res }) => {
+  let statusCode = res.statusCode ? res.statusCode : res.error ? 500 : 200;
+  return {
+    body: res.data ? res.data : res.error,
+    statusCode
+  };
+};
+var toBackendError = ({
+  path,
+  message,
+  code,
+  statusCode = 500
+}) => {
+  console.error(
+    `Autumn middleware error: ${message} (code: ${code}) | path: ${path}`
+  );
+  return {
+    statusCode,
+    body: new AutumnError({
+      message: message || "Internal server error",
+      code: code || "internal_server_error"
+    })
+  };
+};
+
+export {
+  Autumn,
+  fetchPricingTable,
+  toBackendRes,
+  toBackendError
+};

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

@@ -0,0 +1,72 @@
+import {
+  addEntityRoutes
+} from "./chunk-XPNATE4H.mjs";
+import {
+  addGenRoutes
+} from "./chunk-UD4U5ECV.mjs";
+import {
+  withAuth
+} from "./chunk-V7VIK7Q2.mjs";
+import {
+  fetchPricingTable
+} from "./chunk-7SOQYC4B.mjs";
+import {
+  BASE_PATH
+} from "./chunk-KSG3E4Q2.mjs";
+
+// src/libraries/backend/routes/backendRouter.ts
+import { addRoute, createRouter } from "rou3";
+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 = createRouter();
+  addRoute(router, "POST", `${BASE_PATH}/customers`, {
+    handler: createCustomerHandler
+  });
+  addRoute(router, "GET", `${BASE_PATH}/components/pricing_table`, {
+    handler: getPricingTableHandler,
+    requireCustomer: false
+  });
+  addGenRoutes(router);
+  addEntityRoutes(router);
+  return router;
+};
+
+export {
+  createRouterWithOptions
+};

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

@@ -0,0 +1,8 @@
+// src/libraries/backend/constants.ts
+var autumnApiUrl = "https://api.useautumn.com/v1";
+var BASE_PATH = "/api/autumn";
+
+export {
+  autumnApiUrl,
+  BASE_PATH
+};

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

@@ -0,0 +1,99 @@
+import {
+  withAuth
+} from "./chunk-V7VIK7Q2.mjs";
+import {
+  BASE_PATH
+} from "./chunk-KSG3E4Q2.mjs";
+
+// src/libraries/backend/routes/genRoutes.ts
+import { addRoute } from "rou3";
+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) => {
+  addRoute(router, "POST", `${BASE_PATH}/attach`, {
+    handler: attachHandler
+  });
+  addRoute(router, "POST", `${BASE_PATH}/cancel`, {
+    handler: cancelHandler
+  });
+  addRoute(router, "POST", `${BASE_PATH}/check`, {
+    handler: checkHandler
+  });
+  addRoute(router, "POST", `${BASE_PATH}/track`, {
+    handler: trackHandler
+  });
+  addRoute(router, "POST", `${BASE_PATH}/billing_portal`, {
+    handler: openBillingPortalHandler
+  });
+};
+
+export {
+  addGenRoutes
+};

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

@@ -0,0 +1,60 @@
+import {
+  toBackendError,
+  toBackendRes
+} from "./chunk-7SOQYC4B.mjs";
+
+// src/libraries/backend/utils/withAuth.ts
+var withAuth = ({
+  fn,
+  requireCustomer = true
+}) => {
+  return async ({
+    autumn,
+    body,
+    path,
+    getCustomer,
+    pathParams,
+    searchParams
+  }) => {
+    let authResult = await getCustomer();
+    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"
+      });
+    }
+  };
+};
+
+export {
+  withAuth
+};