autumn-js/dist/libraries/backend/tanstack.js

Autumn JS Library

"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)
    __defProp(target, name, { get: all[name], enumerable: true });
};
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
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/libraries/backend/tanstack.ts
var tanstack_exports = {};
__export(tanstack_exports, {
  autumnHandler: () => autumnHandler
});
module.exports = __toCommonJS(tanstack_exports);
var import_rou36 = require("rou3");

// src/sdk/error.ts
var AutumnError = class _AutumnError extends Error {
  message;
  code;
  constructor(response) {
    super(response.message);
    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})`;
  }
  toJSON() {
    return {
      message: this.message,
      code: this.code
    };
  }
};

// src/sdk/general/genMethods.ts
var handleCheckout = async ({
  instance,
  params
}) => {
  return instance.post("/checkout", params);
};
var handleAttach = async ({
  instance,
  params
}) => {
  return instance.post("/attach", params);
};
var handleSetupPayment = async ({
  instance,
  params
}) => {
  return instance.post("/setup_payment", params);
};
var handleCancel = async ({
  instance,
  params
}) => {
  return instance.post("/cancel", 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) {
    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
}) => {
  return instance.get(
    `/customers/${customer_id}/entities/${entity_id}?${getExpandStr2(
      params?.expand
    )}`
  );
};
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/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_beta";
  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/referrals/referralMethods.ts
var referralMethods = (instance) => {
  return {
    createCode: (params) => staticWrapper(createReferralCode, instance, { params }),
    redeemCode: (params) => staticWrapper(redeemReferralCode, instance, { params })
  };
};
var createReferralCode = async ({
  instance,
  params
}) => {
  return instance.post("/referrals/code", params);
};
var redeemReferralCode = async ({
  instance,
  params
}) => {
  return instance.post("/referrals/redeem", params);
};

// src/sdk/response.ts
var toContainerResult = async ({
  response,
  logger: logger2,
  logError = true
}) => {
  if (response.status < 200 || response.status >= 300) {
    let error;
    try {
      error = await response.json();
      if (logError) {
        logger2.error(`[Autumn] ${error.message}`);
      }
    } catch (error2) {
      throw 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) {
    throw error;
    return {
      data: null,
      error: new AutumnError({
        message: "Failed to parse Autumn API response",
        code: "internal_error"
      }),
      statusCode: response?.status
    };
  }
};

// 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;
  headers;
  url;
  logger = console;
  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 && !options?.headers) {
      throw new Error("Autumn secret key or publishable key is required");
    }
    this.headers = options?.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 || 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, logger: this.logger });
  }
  async post(path, body) {
    try {
      const response = await fetch(`${this.url}${path}`, {
        method: "POST",
        headers: this.headers,
        body: JSON.stringify(body)
      });
      return toContainerResult({ response, logger: this.logger });
    } catch (error) {
      console.error("Error sending request:", error);
      throw error;
    }
  }
  async delete(path) {
    const response = await fetch(`${this.url}${path}`, {
      method: "DELETE",
      headers: this.headers
    });
    return toContainerResult({ response, logger: this.logger });
  }
  static customers = customerMethods();
  static products = productMethods();
  static entities = entityMethods();
  static referrals = referralMethods();
  customers = customerMethods(this);
  products = productMethods(this);
  entities = entityMethods(this);
  referrals = referralMethods(this);
  static checkout = (params) => staticWrapper(handleCheckout, void 0, { params });
  async checkout(params) {
    return handleCheckout({
      instance: this,
      params
    });
  }
  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 setupPayment = (params) => staticWrapper(handleSetupPayment, void 0, { params });
  async setupPayment(params) {
    return handleSetupPayment({
      instance: this,
      params
    });
  }
  static cancel = (params) => staticWrapper(handleCancel, void 0, { params });
  async cancel(params) {
    return handleCancel({
      instance: this,
      params
    });
  }
  static check = (params) => staticWrapper(handleCheck, void 0, { params });
  async check(params) {
    return handleCheck({
      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/customers/entities/entTypes.ts
var import_zod = require("zod");
var EntityDataSchema = import_zod.z.object({
  name: import_zod.z.string().optional(),
  feature_id: import_zod.z.string()
});

// src/sdk/general/genTypes.ts
var import_zod2 = require("zod");
var CancelParamsSchema = import_zod2.z.object({
  customer_id: import_zod2.z.string(),
  product_id: import_zod2.z.string(),
  entity_id: import_zod2.z.string().optional(),
  cancel_immediately: import_zod2.z.boolean().optional()
});
var CancelResultSchema = import_zod2.z.object({
  success: import_zod2.z.boolean(),
  customer_id: import_zod2.z.string(),
  product_id: import_zod2.z.string()
});
var TrackParamsSchema = import_zod2.z.object({
  customer_id: import_zod2.z.string(),
  value: import_zod2.z.number().optional(),
  feature_id: import_zod2.z.string().optional(),
  event_name: import_zod2.z.string().optional(),
  entity_id: import_zod2.z.string().optional(),
  customer_data: import_zod2.z.any().optional(),
  idempotency_key: import_zod2.z.string().optional(),
  entity_data: import_zod2.z.any().optional()
});
var TrackResultSchema = import_zod2.z.object({
  id: import_zod2.z.string(),
  code: import_zod2.z.string(),
  customer_id: import_zod2.z.string(),
  feature_id: import_zod2.z.string().optional(),
  event_name: import_zod2.z.string().optional()
});
var CheckParamsSchema = import_zod2.z.object({
  customer_id: import_zod2.z.string(),
  feature_id: import_zod2.z.string().optional(),
  product_id: import_zod2.z.string().optional(),
  entity_id: import_zod2.z.string().optional(),
  customer_data: import_zod2.z.any().optional(),
  required_balance: import_zod2.z.number().optional(),
  send_event: import_zod2.z.boolean().optional(),
  with_preview: import_zod2.z.boolean().optional(),
  entity_data: EntityDataSchema.optional()
});

// src/sdk/customers/cusEnums.ts
var import_zod3 = require("zod");
var CustomerExpandEnum = import_zod3.z.enum([
  "invoices",
  "rewards",
  "trials_used",
  "entities",
  "referrals",
  "payment_method"
]);

// src/sdk/customers/cusTypes.ts
var import_zod4 = require("zod");
var CustomerDataSchema = import_zod4.z.object({
  name: import_zod4.z.string().nullish(),
  email: import_zod4.z.string().nullish(),
  fingerprint: import_zod4.z.string().nullish()
});
var CreateCustomerParamsSchema = import_zod4.z.object({
  id: import_zod4.z.string().nullish(),
  email: import_zod4.z.string().nullish(),
  name: import_zod4.z.string().nullish(),
  fingerprint: import_zod4.z.string().nullish(),
  metadata: import_zod4.z.record(import_zod4.z.any()).optional(),
  expand: import_zod4.z.array(CustomerExpandEnum).optional()
});
var BillingPortalParamsSchema = import_zod4.z.object({
  return_url: import_zod4.z.string().optional()
});

// 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/sdk/referrals/referralTypes.ts
var import_zod5 = require("zod");
var CreateReferralCodeParamsSchema = import_zod5.z.object({
  customer_id: import_zod5.z.string(),
  program_id: import_zod5.z.string()
});
var RedeemReferralCodeParamsSchema = import_zod5.z.object({
  code: import_zod5.z.string(),
  customer_id: import_zod5.z.string()
});

// src/sdk/general/attachTypes.ts
var import_zod6 = require("zod");
var AttachFeatureOptionsSchema = import_zod6.z.object({
  feature_id: import_zod6.z.string(),
  quantity: import_zod6.z.number()
});
var AttachParamsSchema = import_zod6.z.object({
  customer_id: import_zod6.z.string(),
  product_id: import_zod6.z.string().optional(),
  entity_id: import_zod6.z.string().optional(),
  options: import_zod6.z.array(AttachFeatureOptionsSchema).optional(),
  product_ids: import_zod6.z.array(import_zod6.z.string()).optional(),
  free_trial: import_zod6.z.boolean().optional(),
  success_url: import_zod6.z.string().optional(),
  metadata: import_zod6.z.record(import_zod6.z.string()).optional(),
  force_checkout: import_zod6.z.boolean().optional(),
  customer_data: CustomerDataSchema.optional(),
  entity_data: import_zod6.z.any().optional(),
  checkout_session_params: import_zod6.z.record(import_zod6.z.any()).optional(),
  reward: import_zod6.z.string().optional()
});
var AttachResultSchema = import_zod6.z.object({
  checkout_url: import_zod6.z.string().optional(),
  customer_id: import_zod6.z.string(),
  product_ids: import_zod6.z.array(import_zod6.z.string()),
  code: import_zod6.z.string(),
  message: import_zod6.z.string(),
  customer_data: import_zod6.z.any().optional()
});
var CheckoutParamsSchema = import_zod6.z.object({
  customer_id: import_zod6.z.string(),
  product_id: import_zod6.z.string(),
  entity_id: import_zod6.z.string().optional(),
  success_url: import_zod6.z.string().optional(),
  customer_data: CustomerDataSchema.optional(),
  options: import_zod6.z.array(AttachFeatureOptionsSchema).optional()
});

// 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
}) => {
  return {
    statusCode,
    body: new AutumnError({
      message: message || "Internal server error",
      code: code || "internal_server_error"
    })
  };
};

// src/libraries/backend/utils/withAuth.ts
var withAuth = ({
  fn,
  requireCustomer = true
}) => {
  return async ({
    autumn,
    body,
    path,
    getCustomer: getCustomer2,
    pathParams,
    searchParams
  }) => {
    let authResult = await getCustomer2();
    let customerId = authResult?.customerId;
    if (!customerId && requireCustomer) {
      if (body?.errorOnNotFound === false) {
        return {
          statusCode: 202,
          body: null
        };
      } else {
        logger.error(
          `[Autumn]: customerId returned from identify function is ${customerId}`
        );
        return toBackendError({
          path,
          message: `customerId returned from identify function is ${customerId}`,
          code: "no_customer_id",
          statusCode: 401
        });
      }
    }
    let cusData = authResult?.customerData || body?.customer_data;
    try {
      let res = await fn({
        body,
        autumn,
        customer_id: customerId,
        customer_data: cusData,
        pathParams,
        searchParams
      });
      return toBackendRes({ res });
    } catch (error) {
      logger.error(`${error.message}`);
      return toBackendError({
        path,
        message: error.message || "unknown error",
        code: "internal_error"
      });
    }
  };
};

// src/libraries/backend/routes/genRoutes.ts
var import_rou3 = require("rou3");
var sanitizeBody = (body) => {
  let bodyCopy = { ...body };
  delete bodyCopy.customer_id;
  delete bodyCopy.customer_data;
  return bodyCopy;
};
var checkoutHandler = withAuth({
  fn: async ({
    autumn,
    customer_id,
    customer_data,
    body
  }) => {
    return await autumn.checkout({
      ...sanitizeBody(body),
      customer_id,
      customer_data
    });
  }
});
var attachHandler = withAuth({
  fn: async ({
    autumn,
    customer_id,
    customer_data,
    body
  }) => {
    return await autumn.attach({
      ...sanitizeBody(body),
      customer_id,
      customer_data
    });
  }
});
var setupPaymentHandler = withAuth({
  fn: async ({
    autumn,
    customer_id,
    customer_data,
    body
  }) => {
    return await autumn.setupPayment({
      ...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
  }) => {
    const result = await autumn.check({
      ...sanitizeBody(body),
      customer_id,
      customer_data
    });
    return result;
  }
});
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}/checkout`, {
    handler: checkoutHandler
  });
  (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
  });
  (0, import_rou3.addRoute)(router, "POST", `${BASE_PATH}/setup_payment`, {
    handler: setupPaymentHandler
  });
};

// src/libraries/backend/routes/backendRouter.ts
var import_rou35 = 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/referralRoutes.ts
var import_rou33 = require("rou3");
var createReferralCodeHandler = withAuth({
  fn: async ({
    autumn,
    customer_id,
    body
  }) => {
    return await autumn.referrals.createCode({
      ...body,
      customer_id
    });
  }
});
var redeemReferralCodeHandler = withAuth({
  fn: async ({
    autumn,
    customer_id,
    body
  }) => {
    return await autumn.referrals.redeemCode({
      ...body,
      customer_id
    });
  }
});
var addReferralRoutes = async (router) => {
  (0, import_rou33.addRoute)(router, "POST", `${BASE_PATH}/referrals/code`, {
    handler: createReferralCodeHandler
  });
  (0, import_rou33.addRoute)(router, "POST", `${BASE_PATH}/referrals/redeem`, {
    handler: redeemReferralCodeHandler
  });
};

// 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 };
  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 = () => {
  const router = (0, import_rou35.createRouter)();
  (0, import_rou35.addRoute)(router, "POST", `${BASE_PATH}/cors`, {
    handler: () => {
      return {
        body: {
          message: "OK"
        },
        statusCode: 200
      };
    }
  });
  (0, import_rou35.addRoute)(router, "POST", `${BASE_PATH}/customers`, {
    handler: createCustomerHandler
  });
  (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;
};

// ../node_modules/.pnpm/cookie-es@1.2.2/node_modules/cookie-es/dist/index.mjs
function splitSetCookieString(cookiesString) {
  if (Array.isArray(cookiesString)) {
    return cookiesString.flatMap((c) => splitSetCookieString(c));
  }
  if (typeof cookiesString !== "string") {
    return [];
  }
  const cookiesStrings = [];
  let pos = 0;
  let start;
  let ch;
  let lastComma;
  let nextStart;
  let cookiesSeparatorFound;
  const skipWhitespace = () => {
    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
      pos += 1;
    }
    return pos < cookiesString.length;
  };
  const notSpecialChar = () => {
    ch = cookiesString.charAt(pos);
    return ch !== "=" && ch !== ";" && ch !== ",";
  };
  while (pos < cookiesString.length) {
    start = pos;
    cookiesSeparatorFound = false;
    while (skipWhitespace()) {
      ch = cookiesString.charAt(pos);
      if (ch === ",") {
        lastComma = pos;
        pos += 1;
        skipWhitespace();
        nextStart = pos;
        while (pos < cookiesString.length && notSpecialChar()) {
          pos += 1;
        }
        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
          cookiesSeparatorFound = true;
          pos = nextStart;
          cookiesStrings.push(cookiesString.slice(start, lastComma));
          start = pos;
        } else {
          pos = lastComma + 1;
        }
      } else {
        pos += 1;
      }
    }
    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
      cookiesStrings.push(cookiesString.slice(start, cookiesString.length));
    }
  }
  return cookiesStrings;
}

// ../node_modules/.pnpm/@tanstack+start-client-core@1.121.34/node_modules/@tanstack/start-client-core/dist/esm/headers.js
function toHeadersInstance(init) {
  if (init instanceof Headers) {
    return new Headers(init);
  } else if (Array.isArray(init)) {
    return new Headers(init);
  } else if (typeof init === "object") {
    return new Headers(init);
  } else {
    return new Headers();
  }
}
function mergeHeaders(...headers) {
  return headers.reduce((acc, header) => {
    const headersInstance = toHeadersInstance(header);
    for (const [key, value] of headersInstance.entries()) {
      if (key === "set-cookie") {
        const splitCookies = splitSetCookieString(value);
        splitCookies.forEach((cookie) => acc.append("set-cookie", cookie));
      } else {
        acc.set(key, value);
      }
    }
    return acc;
  }, new Headers());
}

// ../node_modules/.pnpm/@tanstack+start-client-core@1.121.34/node_modules/@tanstack/start-client-core/dist/esm/json.js
function json(payload, init) {
  return new Response(JSON.stringify(payload), {
    ...init,
    headers: mergeHeaders(
      { "content-type": "application/json" },
      init == null ? void 0 : init.headers
    )
  });
}

// 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 };
};

// src/libraries/backend/tanstack.ts
var autumnHandler = (options) => {
  const autumn = new Autumn({
    url: autumnApiUrl,
    version: options.version
  });
  const router = createRouterWithOptions();
  let { found, error: resError } = secretKeyCheck(options?.secretKey);
  const handleRequest = async (ctx) => {
    const { request } = ctx;
    if (!found && !options.secretKey) {
      return new Response(JSON.stringify(resError), {
        status: resError.statusCode
      });
    }
    const url = new URL(request.url);
    const searchParams = Object.fromEntries(url.searchParams);
    const pathname = url.pathname;
    const method = request.method;
    const match = (0, import_rou36.findRoute)(router, method, pathname);
    if (!match) {
      return new Response(JSON.stringify({ error: "Not found" }), {
        status: 404,
        headers: { "Content-Type": "application/json" }
      });
    }
    const { data, params: pathParams } = match;
    const { handler } = data;
    let body = null;
    if (method === "POST" || method === "PUT" || method === "PATCH") {
      try {
        body = await request.json();
      } catch (error) {
      }
    }
    try {
      const result = await handler({
        autumn,
        body,
        path: pathname,
        getCustomer: async () => await options.identify(ctx),
        pathParams,
        searchParams
      });
      return json(result.body, { status: result.statusCode });
    } catch (error) {
      console.error("Autumn handler error:", error.message);
      return json({ error: error.message }, { status: 500 });
    }
  };
  return {
    GET: handleRequest,
    POST: handleRequest,
    PUT: handleRequest,
    PATCH: handleRequest,
    DELETE: handleRequest
  };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  autumnHandler
});