autumn-js 0.0.34 → 0.0.36

package/dist/libraries/backend/chunk-22YI4G4C.mjs

@@ -0,0 +1,99 @@
+import {
+  withAuth
+} from "./chunk-GLXPM3SH.mjs";
+import {
+  BASE_PATH
+} from "./chunk-ST6FAZAJ.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}/openBillingPortal`, {
+    handler: openBillingPortalHandler
+  });
+};
+
+export {
+  addGenRoutes
+};

package/dist/libraries/backend/chunk-254RDJHP.mjs

@@ -0,0 +1,67 @@
+import {
+  addGenRoutes
+} from "./chunk-YOPV7M2C.mjs";
+import {
+  withAuth
+} from "./chunk-OX3SUKTI.mjs";
+import {
+  BASE_PATH
+} from "./chunk-ST6FAZAJ.mjs";
+import {
+  fetchPricingTable
+} from "./chunk-LUGIN7PL.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
+  }) => {
+    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);
+  return router;
+};
+
+export {
+  createRouterWithOptions
+};

package/dist/libraries/backend/chunk-2BGK5SYQ.mjs

@@ -0,0 +1,56 @@
+import {
+  toBackendError,
+  toBackendRes
+} from "./chunk-4ZZPTUK5.mjs";
+
+// src/libraries/backend/utils/withAuth.ts
+var withAuth = ({
+  fn,
+  requireCustomer = true
+}) => {
+  return async ({
+    autumn,
+    body,
+    path,
+    getCustomer
+  }) => {
+    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
+      });
+      return toBackendRes({ res });
+    } catch (error) {
+      return toBackendError({
+        path,
+        message: error.message || "unknown error",
+        code: "internal_error"
+      });
+    }
+  };
+};
+
+export {
+  withAuth
+};

package/dist/libraries/backend/chunk-2DGZWDTA.mjs

@@ -0,0 +1,56 @@
+import {
+  toBackendError,
+  toBackendRes
+} from "./chunk-4BNMJOKS.mjs";
+
+// src/libraries/backend/utils/withAuth.ts
+var withAuth = ({
+  fn,
+  requireCustomer = true
+}) => {
+  return async ({
+    autumn,
+    body,
+    path,
+    getCustomer
+  }) => {
+    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
+      });
+      return toBackendRes({ res });
+    } catch (error) {
+      return toBackendError({
+        path,
+        message: error.message || "unknown error",
+        code: "internal_error"
+      });
+    }
+  };
+};
+
+export {
+  withAuth
+};

package/dist/libraries/backend/chunk-2GBZQN57.mjs

@@ -0,0 +1,45 @@
+import {
+  toBackendError,
+  toBackendRes
+} from "./chunk-4IQ6Z3P3.mjs";
+
+// src/libraries/backend/utils/withAuth.ts
+var withAuth = ({
+  fn
+}) => {
+  return async ({
+    autumn,
+    body,
+    path,
+    getCustomer
+  }) => {
+    let authResult = await getCustomer();
+    if (!authResult) {
+      return toBackendError({
+        path,
+        message: "No customer ID found",
+        code: "no_customer_id"
+      });
+    }
+    let cusData = authResult?.customerData;
+    try {
+      let res = await fn({
+        body,
+        autumn,
+        customer_id: authResult?.customerId,
+        customer_data: cusData
+      });
+      return toBackendRes({ res });
+    } catch (error) {
+      return toBackendError({
+        path,
+        message: error.message || "unknown error",
+        code: "internal_error"
+      });
+    }
+  };
+};
+
+export {
+  withAuth
+};

package/dist/libraries/backend/chunk-2KVO3KPR.mjs

@@ -0,0 +1,64 @@
+import {
+  addGenRoutes
+} from "./chunk-HE44YLBC.mjs";
+import {
+  withAuth
+} from "./chunk-BHCUTIQ2.mjs";
+import {
+  fetchPricingTable
+} from "./chunk-YNBU6II7.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
+  }) => {
+    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);
+  return router;
+};
+
+export {
+  createRouterWithOptions
+};

package/dist/libraries/backend/chunk-2LL7RNLL.mjs

@@ -0,0 +1,272 @@
+import {
+  withAuth
+} from "./chunk-ED7NOZIN.mjs";
+
+// node_modules/rou3/dist/index.mjs
+var EmptyObject = /* @__PURE__ */ (() => {
+  const C = function() {
+  };
+  C.prototype = /* @__PURE__ */ Object.create(null);
+  return C;
+})();
+function createRouter() {
+  const ctx = {
+    root: { key: "" },
+    static: new EmptyObject()
+  };
+  return ctx;
+}
+function splitPath(path) {
+  return path.split("/").filter(Boolean);
+}
+function getMatchParams(segments, paramsMap) {
+  const params = new EmptyObject();
+  for (const [index, name] of paramsMap) {
+    const segment = index < 0 ? segments.slice(-1 * index).join("/") : segments[index];
+    if (typeof name === "string") {
+      params[name] = segment;
+    } else {
+      const match = segment.match(name);
+      if (match) {
+        for (const key in match.groups) {
+          params[key] = match.groups[key];
+        }
+      }
+    }
+  }
+  return params;
+}
+function addRoute(ctx, method = "", path, data) {
+  const segments = splitPath(path);
+  let node = ctx.root;
+  let _unnamedParamIndex = 0;
+  const paramsMap = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment.startsWith("**")) {
+      if (!node.wildcard) {
+        node.wildcard = { key: "**" };
+      }
+      node = node.wildcard;
+      paramsMap.push([
+        -i,
+        segment.split(":")[1] || "_",
+        segment.length === 2
+      ]);
+      break;
+    }
+    if (segment === "*" || segment.includes(":")) {
+      if (!node.param) {
+        node.param = { key: "*" };
+      }
+      node = node.param;
+      const isOptional = segment === "*";
+      paramsMap.push([
+        i,
+        isOptional ? `_${_unnamedParamIndex++}` : _getParamMatcher(segment),
+        isOptional
+      ]);
+      continue;
+    }
+    const child = node.static?.[segment];
+    if (child) {
+      node = child;
+    } else {
+      const staticNode = { key: segment };
+      if (!node.static) {
+        node.static = new EmptyObject();
+      }
+      node.static[segment] = staticNode;
+      node = staticNode;
+    }
+  }
+  const hasParams = paramsMap.length > 0;
+  if (!node.methods) {
+    node.methods = new EmptyObject();
+  }
+  if (!node.methods[method]) {
+    node.methods[method] = [];
+  }
+  node.methods[method].push({
+    data: data || null,
+    paramsMap: hasParams ? paramsMap : void 0
+  });
+  if (!hasParams) {
+    ctx.static[path] = node;
+  }
+}
+function _getParamMatcher(segment) {
+  if (!segment.includes(":", 1)) {
+    return segment.slice(1);
+  }
+  const regex = segment.replace(/:(\w+)/g, (_, id) => `(?<${id}>\\w+)`);
+  return new RegExp(`^${regex}$`);
+}
+function findRoute(ctx, method = "", path, opts) {
+  if (path[path.length - 1] === "/") {
+    path = path.slice(0, -1);
+  }
+  const staticNode = ctx.static[path];
+  if (staticNode && staticNode.methods) {
+    const staticMatch = staticNode.methods[method] || staticNode.methods[""];
+    if (staticMatch !== void 0) {
+      return staticMatch[0];
+    }
+  }
+  const segments = splitPath(path);
+  const match = _lookupTree(ctx, ctx.root, method, segments, 0)?.[0];
+  if (match === void 0) {
+    return;
+  }
+  if (opts?.params === false) {
+    return match;
+  }
+  return {
+    data: match.data,
+    params: match.paramsMap ? getMatchParams(segments, match.paramsMap) : void 0
+  };
+}
+function _lookupTree(ctx, node, method, segments, index) {
+  if (index === segments.length) {
+    if (node.methods) {
+      const match = node.methods[method] || node.methods[""];
+      if (match) {
+        return match;
+      }
+    }
+    if (node.param && node.param.methods) {
+      const match = node.param.methods[method] || node.param.methods[""];
+      if (match) {
+        const pMap = match[0].paramsMap;
+        if (pMap?.[pMap?.length - 1]?.[2]) {
+          return match;
+        }
+      }
+    }
+    if (node.wildcard && node.wildcard.methods) {
+      const match = node.wildcard.methods[method] || node.wildcard.methods[""];
+      if (match) {
+        const pMap = match[0].paramsMap;
+        if (pMap?.[pMap?.length - 1]?.[2]) {
+          return match;
+        }
+      }
+    }
+    return void 0;
+  }
+  const segment = segments[index];
+  if (node.static) {
+    const staticChild = node.static[segment];
+    if (staticChild) {
+      const match = _lookupTree(ctx, staticChild, method, segments, index + 1);
+      if (match) {
+        return match;
+      }
+    }
+  }
+  if (node.param) {
+    const match = _lookupTree(ctx, node.param, method, segments, index + 1);
+    if (match) {
+      return match;
+    }
+  }
+  if (node.wildcard && node.wildcard.methods) {
+    return node.wildcard.methods[method] || node.wildcard.methods[""];
+  }
+  return;
+}
+
+// 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) => {
+  addRoute(router, "POST", "/attach", {
+    handler: attachHandler
+  });
+  addRoute(router, "POST", "/cancel", {
+    handler: cancelHandler
+  });
+  addRoute(router, "POST", "/check", {
+    handler: checkHandler
+  });
+  addRoute(router, "POST", "/track", {
+    handler: trackHandler
+  });
+  addRoute(router, "POST", "/openBillingPortal", {
+    handler: openBillingPortalHandler
+  });
+};
+
+export {
+  createRouter,
+  addRoute,
+  findRoute,
+  addGenRoutes
+};

package/dist/libraries/backend/chunk-2LY57Q7D.mjs

@@ -0,0 +1,56 @@
+import {
+  toBackendError,
+  toBackendRes
+} from "./chunk-OQIGISCW.mjs";
+
+// src/libraries/backend/utils/withAuth.ts
+var withAuth = ({
+  fn,
+  requireCustomer = true
+}) => {
+  return async ({
+    autumn,
+    body,
+    path,
+    getCustomer
+  }) => {
+    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
+      });
+      return toBackendRes({ res });
+    } catch (error) {
+      return toBackendError({
+        path,
+        message: error.message || "unknown error",
+        code: "internal_error"
+      });
+    }
+  };
+};
+
+export {
+  withAuth
+};