@stardeckai/autumn-js 0.1.85

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-LM7CBUUT.mjs

@@ -0,0 +1,95 @@
+import {
+  addEntityRoutes
+} from "./chunk-ZGBFNNRL.mjs";
+import {
+  addGenRoutes
+} from "./chunk-7AOVJSWM.mjs";
+import {
+  addProductRoutes
+} from "./chunk-ZW3KBZDU.mjs";
+import {
+  addReferralRoutes
+} from "./chunk-4LJK3VUJ.mjs";
+import {
+  addAnalyticsRoutes
+} from "./chunk-ENC3BP6R.mjs";
+import {
+  withAuth
+} from "./chunk-NRKSUO62.mjs";
+import {
+  fetchPricingTable
+} from "./chunk-IZDJ3I6T.mjs";
+import {
+  BASE_PATH
+} from "./chunk-KSG3E4Q2.mjs";
+
+// src/libraries/backend/routes/backendRouter.ts
+import { addRoute, createRouter } from "rou3";
+var sanitizeCustomerBody = (body) => {
+  const bodyCopy = { ...body };
+  delete bodyCopy.id;
+  delete bodyCopy.name;
+  delete bodyCopy.email;
+  return bodyCopy;
+};
+var createCustomerHandler = (options) => withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    customer_data = {},
+    body
+  }) => {
+    const res = await autumn.customers.create({
+      id: customer_id,
+      ...customer_data,
+      ...sanitizeCustomerBody(body)
+    });
+    return res;
+  },
+  suppressLogs: options?.suppressLogs
+});
+var getPricingTableHandler = (options) => withAuth({
+  fn: async ({
+    autumn,
+    customer_id
+  }) => {
+    return await fetchPricingTable({
+      instance: autumn,
+      params: {
+        customer_id: customer_id || void 0
+      }
+    });
+  },
+  requireCustomer: false,
+  suppressLogs: options?.suppressLogs
+});
+var createRouterWithOptions = (options) => {
+  const router = createRouter();
+  addRoute(router, "POST", `${BASE_PATH}/cors`, {
+    handler: () => {
+      return {
+        body: {
+          message: "OK"
+        },
+        statusCode: 200
+      };
+    }
+  });
+  addRoute(router, "POST", `${BASE_PATH}/customers`, {
+    handler: createCustomerHandler(options)
+  });
+  addRoute(router, "GET", `${BASE_PATH}/components/pricing_table`, {
+    handler: getPricingTableHandler(options),
+    requireCustomer: false
+  });
+  addGenRoutes(router, options);
+  addEntityRoutes(router, options);
+  addReferralRoutes(router, options);
+  addProductRoutes(router, options);
+  addAnalyticsRoutes(router, options);
+  return router;
+};
+
+export {
+  createRouterWithOptions
+};

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

@@ -0,0 +1,115 @@
+import {
+  toBackendError,
+  toBackendRes
+} from "./chunk-IZDJ3I6T.mjs";
+import {
+  logger
+} from "./chunk-SGEUXFOF.mjs";
+
+// src/utils/toSnakeCase.ts
+function stringToSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+var toSnakeCase = ({
+  obj,
+  excludeKeys,
+  excludeChildrenOf
+}) => {
+  if (Array.isArray(obj)) {
+    return obj.map(
+      (item) => toSnakeCase({ obj: item, excludeKeys, excludeChildrenOf })
+    );
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => {
+        const snakeKey = stringToSnakeCase(key);
+        if (excludeKeys?.includes(key)) {
+          return [key, value];
+        }
+        if (excludeChildrenOf?.includes(key)) {
+          return [snakeKey, value];
+        }
+        return [
+          snakeKey,
+          toSnakeCase({
+            obj: value,
+            excludeKeys,
+            excludeChildrenOf
+          })
+        ];
+      })
+    );
+  }
+  return obj;
+};
+
+// src/libraries/backend/utils/withAuth.ts
+var withAuth = ({
+  fn,
+  requireCustomer = true,
+  suppressLogs = false
+}) => {
+  return async ({
+    autumn,
+    body,
+    path,
+    getCustomer,
+    pathParams,
+    searchParams
+  }) => {
+    let authResult = await getCustomer();
+    let customerId = authResult?.customerId;
+    if (!customerId && requireCustomer) {
+      if (body?.errorOnNotFound === false) {
+        return {
+          statusCode: 202,
+          body: null
+        };
+      } else {
+        if (!suppressLogs) {
+          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;
+    if (body) {
+      body = toSnakeCase({
+        obj: body,
+        excludeChildrenOf: ["checkoutSessionParams", "properties"]
+      });
+    }
+    try {
+      let res = await fn({
+        body,
+        autumn,
+        customer_id: customerId,
+        customer_data: cusData,
+        pathParams,
+        searchParams
+      });
+      return toBackendRes({ res });
+    } catch (error) {
+      if (!suppressLogs) {
+        logger.error(`${error.message}`);
+      }
+      return toBackendError({
+        path,
+        message: error.message || "unknown error",
+        code: "internal_error"
+      });
+    }
+  };
+};
+
+export {
+  toSnakeCase,
+  withAuth
+};

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

@@ -0,0 +1,40 @@
+// src/utils/logger.ts
+var getTime = () => {
+  const 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(), "DEBUG", ...args);
+    }
+  },
+  log: (...args) => {
+    console.log(getTime(), "INFO", ...args);
+  },
+  info: (...args) => {
+    if (greaterThanLevel("info")) {
+      console.log(getTime(), "INFO", ...args);
+    }
+  },
+  warn: (...args) => {
+    if (greaterThanLevel("warn")) {
+      console.log(getTime(), "WARN", ...args);
+    }
+  },
+  error: (...args) => {
+    if (greaterThanLevel("error")) {
+      console.log(getTime(), "ERROR", ...args);
+    }
+  }
+};
+
+export {
+  logger
+};

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

@@ -0,0 +1,104 @@
+// src/libraries/backend/utils/betterAuth/middlewares.ts
+import { getSessionFromCtx } from "better-auth/api";
+var scopeContainsOrg = ({ options }) => {
+  return options?.customerScope === "organization" || options?.customerScope === "user_and_organization";
+};
+async function getOrganizationContext(ctx, options) {
+  if (!scopeContainsOrg({ options }) && !options?.identify) {
+    return {
+      activeOrganizationId: null,
+      activeOrganization: null,
+      activeOrganizationEmail: null
+    };
+  }
+  try {
+    const session = await getSessionFromCtx(ctx);
+    const orgId = session?.session.activeOrganizationId;
+    if (orgId && session) {
+      const [member, organization] = await Promise.all([
+        ctx.context.adapter.findOne({
+          model: "member",
+          where: [
+            { field: "userId", value: session.user.id },
+            { field: "organizationId", value: orgId }
+          ]
+        }),
+        ctx.context.adapter.findOne({
+          model: "organization",
+          where: [{ field: "id", value: orgId }]
+        })
+      ]);
+      if (!member) {
+        return {
+          activeOrganizationId: null,
+          activeOrganization: null,
+          activeOrganizationEmail: null
+        };
+      }
+      const creatorRole = ctx.context.orgOptions?.creatorRole || "owner";
+      let ownerUserId = member.role === creatorRole ? member.userId : null;
+      let owner = null;
+      if (member.role !== creatorRole) {
+        const ownerMembers = await ctx.context.adapter.findMany({
+          model: "member",
+          where: [
+            { field: "organizationId", value: orgId },
+            { field: "role", value: creatorRole }
+          ]
+        });
+        ownerUserId = ownerMembers.length > 0 ? ownerMembers[0].userId : null;
+      }
+      if (ownerUserId) {
+        const ownerUser = await ctx.context.adapter.findOne({
+          model: "user",
+          where: [{ field: "id", value: ownerUserId }]
+        });
+        owner = ownerUser;
+      }
+      return {
+        activeOrganizationId: orgId,
+        activeOrganization: organization,
+        activeOrganizationEmail: owner?.email
+      };
+    }
+    return {
+      activeOrganizationId: null,
+      activeOrganization: null,
+      activeOrganizationEmail: null
+    };
+  } catch (error) {
+    console.log("[org context error]", error);
+    return {
+      activeOrganizationId: null,
+      activeOrganization: null,
+      activeOrganizationEmail: null
+    };
+  }
+}
+async function getIdentityContext({
+  orgContext,
+  options,
+  session
+}) {
+  if (!options?.identify) return null;
+  const orgData = orgContext.activeOrganization?.id ? {
+    ...orgContext.activeOrganization,
+    ownerEmail: orgContext.activeOrganizationEmail
+  } : null;
+  try {
+    const identity = await options.identify({
+      session,
+      organization: orgData
+    });
+    return identity;
+  } catch (error) {
+    console.log("[identity context error]", error);
+    return null;
+  }
+}
+
+export {
+  scopeContainsOrg,
+  getOrganizationContext,
+  getIdentityContext
+};

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-ZGBFNNRL.mjs

@@ -0,0 +1,78 @@
+import {
+  withAuth
+} from "./chunk-NRKSUO62.mjs";
+
+// src/libraries/backend/routes/entityRoutes.ts
+import { addRoute } from "rou3";
+var createEntityHandler = (options) => withAuth({
+  fn: async ({
+    autumn,
+    customer_id,
+    body
+  }) => {
+    return await autumn.entities.create(customer_id, body);
+  },
+  suppressLogs: options?.suppressLogs
+});
+var getEntityHandler = (options) => 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;
+  },
+  suppressLogs: options?.suppressLogs
+});
+var deleteEntityHandler = (options) => 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);
+  },
+  suppressLogs: options?.suppressLogs
+});
+var addEntityRoutes = async (router, options) => {
+  addRoute(router, "POST", "/api/autumn/entities", {
+    handler: createEntityHandler(options)
+  });
+  addRoute(router, "GET", "/api/autumn/entities/:entityId", {
+    handler: getEntityHandler(options)
+  });
+  addRoute(router, "DELETE", "/api/autumn/entities/:entityId", {
+    handler: deleteEntityHandler(options)
+  });
+};
+
+export {
+  addEntityRoutes
+};

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

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

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

@@ -0,0 +1,4 @@
+declare const autumnApiUrl = "https://api.useautumn.com/v1";
+declare const BASE_PATH = "/api/autumn";
+
+export { BASE_PATH, autumnApiUrl };

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

@@ -0,0 +1,4 @@
+declare const autumnApiUrl = "https://api.useautumn.com/v1";
+declare const BASE_PATH = "/api/autumn";
+
+export { BASE_PATH, autumnApiUrl };

package/dist/libraries/backend/constants.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/libraries/backend/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  BASE_PATH: () => BASE_PATH,
+  autumnApiUrl: () => autumnApiUrl
+});
+module.exports = __toCommonJS(constants_exports);
+var autumnApiUrl = "https://api.useautumn.com/v1";
+var BASE_PATH = "/api/autumn";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASE_PATH,
+  autumnApiUrl
+});

package/dist/libraries/backend/constants.mjs

@@ -0,0 +1,8 @@
+import {
+  BASE_PATH,
+  autumnApiUrl
+} from "./chunk-KSG3E4Q2.mjs";
+export {
+  BASE_PATH,
+  autumnApiUrl
+};

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

@@ -0,0 +1,16 @@
+import { AuthResult } from './utils/AuthFunction.mjs';
+
+declare function autumnHandler(options: {
+    httpAction: any;
+    identify: (ctx: any, request: any) => AuthResult;
+    url?: string;
+    secretKey?: string;
+}): any;
+declare function convexHandler(options: {
+    identity: Awaited<AuthResult>;
+    url?: string;
+    secretKey?: string;
+    corsOrigin?: string;
+}): (ctx: any, request: Request) => Promise<Response>;
+
+export { autumnHandler, convexHandler };

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

@@ -0,0 +1,16 @@
+import { AuthResult } from './utils/AuthFunction.js';
+
+declare function autumnHandler(options: {
+    httpAction: any;
+    identify: (ctx: any, request: any) => AuthResult;
+    url?: string;
+    secretKey?: string;
+}): any;
+declare function convexHandler(options: {
+    identity: Awaited<AuthResult>;
+    url?: string;
+    secretKey?: string;
+    corsOrigin?: string;
+}): (ctx: any, request: Request) => Promise<Response>;
+
+export { autumnHandler, convexHandler };