@stardeckai/autumn-js 0.1.85

package/dist/libraries/backend/utils/backendRes.mjs

@@ -0,0 +1,10 @@
+import {
+  toBackendError,
+  toBackendRes
+} from "../chunk-IZDJ3I6T.mjs";
+import "../chunk-SGEUXFOF.mjs";
+import "../chunk-KSG3E4Q2.mjs";
+export {
+  toBackendError,
+  toBackendRes
+};

package/dist/libraries/backend/utils/betterAuth/middlewares.d.mts

@@ -0,0 +1,26 @@
+import { AutumnOptions } from './types.mjs';
+import 'better-auth/plugins';
+import '../AuthFunction.mjs';
+import 'better-auth/api';
+
+declare const scopeContainsOrg: ({ options }: {
+    options?: AutumnOptions;
+}) => boolean;
+declare function getOrganizationContext(ctx: any, options?: AutumnOptions): Promise<{
+    activeOrganizationId: any;
+    activeOrganization: any;
+    activeOrganizationEmail: any;
+}>;
+declare function getIdentityContext({ orgContext, options, session, }: {
+    orgContext: any;
+    options?: AutumnOptions;
+    session?: any;
+}): Promise<{
+    customerId?: string;
+    customerData?: {
+        name?: string;
+        email?: string;
+    };
+} | null>;
+
+export { getIdentityContext, getOrganizationContext, scopeContainsOrg };

package/dist/libraries/backend/utils/betterAuth/middlewares.d.ts

@@ -0,0 +1,26 @@
+import { AutumnOptions } from './types.js';
+import 'better-auth/plugins';
+import '../AuthFunction.js';
+import 'better-auth/api';
+
+declare const scopeContainsOrg: ({ options }: {
+    options?: AutumnOptions;
+}) => boolean;
+declare function getOrganizationContext(ctx: any, options?: AutumnOptions): Promise<{
+    activeOrganizationId: any;
+    activeOrganization: any;
+    activeOrganizationEmail: any;
+}>;
+declare function getIdentityContext({ orgContext, options, session, }: {
+    orgContext: any;
+    options?: AutumnOptions;
+    session?: any;
+}): Promise<{
+    customerId?: string;
+    customerData?: {
+        name?: string;
+        email?: string;
+    };
+} | null>;
+
+export { getIdentityContext, getOrganizationContext, scopeContainsOrg };

package/dist/libraries/backend/utils/betterAuth/middlewares.js

@@ -0,0 +1,130 @@
+"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/utils/betterAuth/middlewares.ts
+var middlewares_exports = {};
+__export(middlewares_exports, {
+  getIdentityContext: () => getIdentityContext,
+  getOrganizationContext: () => getOrganizationContext,
+  scopeContainsOrg: () => scopeContainsOrg
+});
+module.exports = __toCommonJS(middlewares_exports);
+var import_api = require("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 (0, import_api.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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getIdentityContext,
+  getOrganizationContext,
+  scopeContainsOrg
+});

package/dist/libraries/backend/utils/betterAuth/middlewares.mjs

@@ -0,0 +1,10 @@
+import {
+  getIdentityContext,
+  getOrganizationContext,
+  scopeContainsOrg
+} from "../../chunk-SRJD6EXQ.mjs";
+export {
+  getIdentityContext,
+  getOrganizationContext,
+  scopeContainsOrg
+};

package/dist/libraries/backend/utils/betterAuth/types.d.mts

@@ -0,0 +1,19 @@
+import { Organization } from 'better-auth/plugins';
+import { AuthResult } from '../AuthFunction.mjs';
+import { getSessionFromCtx } from 'better-auth/api';
+
+type Session = ReturnType<typeof getSessionFromCtx>;
+type AutumnOptions = {
+    url?: string;
+    secretKey?: string;
+    customerScope?: "user" | "organization" | "user_and_organization";
+    identify?: (options: {
+        session: Session;
+        organization?: (Organization & {
+            ownerEmail: string | null;
+        }) | null;
+    }) => AuthResult;
+    suppressLogs?: boolean;
+};
+
+export type { AutumnOptions, Session };

package/dist/libraries/backend/utils/betterAuth/types.d.ts

@@ -0,0 +1,19 @@
+import { Organization } from 'better-auth/plugins';
+import { AuthResult } from '../AuthFunction.js';
+import { getSessionFromCtx } from 'better-auth/api';
+
+type Session = ReturnType<typeof getSessionFromCtx>;
+type AutumnOptions = {
+    url?: string;
+    secretKey?: string;
+    customerScope?: "user" | "organization" | "user_and_organization";
+    identify?: (options: {
+        session: Session;
+        organization?: (Organization & {
+            ownerEmail: string | null;
+        }) | null;
+    }) => AuthResult;
+    suppressLogs?: boolean;
+};
+
+export type { AutumnOptions, Session };

package/dist/libraries/backend/utils/betterAuth/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/utils/betterAuth/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/libraries/backend/utils/logBackendErrors.d.mts

@@ -0,0 +1,5 @@
+import { R as Result, A as AutumnError } from '../response-BBvvMvoC.mjs';
+
+declare const logBackendErrors: (res: Result<any, AutumnError>) => Promise<void>;
+
+export { logBackendErrors };

package/dist/libraries/backend/utils/logBackendErrors.d.ts

@@ -0,0 +1,5 @@
+import { R as Result, A as AutumnError } from '../response-BBvvMvoC.js';
+
+declare const logBackendErrors: (res: Result<any, AutumnError>) => Promise<void>;
+
+export { logBackendErrors };

package/dist/libraries/backend/utils/logBackendErrors.js

@@ -0,0 +1,73 @@
+"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/utils/logBackendErrors.ts
+var logBackendErrors_exports = {};
+__export(logBackendErrors_exports, {
+  logBackendErrors: () => logBackendErrors
+});
+module.exports = __toCommonJS(logBackendErrors_exports);
+
+// 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);
+    }
+  }
+};
+
+// src/libraries/backend/utils/logBackendErrors.ts
+var logBackendErrors = async (res) => {
+  let { statusCode, error } = res;
+  if (!error) return;
+  logger.error(`[Autumn] ${error.message}`);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  logBackendErrors
+});

package/dist/libraries/backend/utils/logBackendErrors.mjs

@@ -0,0 +1,13 @@
+import {
+  logger
+} from "../chunk-SGEUXFOF.mjs";
+
+// src/libraries/backend/utils/logBackendErrors.ts
+var logBackendErrors = async (res) => {
+  let { statusCode, error } = res;
+  if (!error) return;
+  logger.error(`[Autumn] ${error.message}`);
+};
+export {
+  logBackendErrors
+};

package/dist/libraries/backend/utils/secretKeyCheck.d.mts

@@ -0,0 +1,13 @@
+declare const secretKeyCheck: (secretKey?: string) => {
+    found: boolean;
+    error: {
+        statusCode: number;
+        message: string;
+        code: string;
+    };
+} | {
+    found: boolean;
+    error: null;
+};
+
+export { secretKeyCheck };

package/dist/libraries/backend/utils/secretKeyCheck.d.ts

@@ -0,0 +1,13 @@
+declare const secretKeyCheck: (secretKey?: string) => {
+    found: boolean;
+    error: {
+        statusCode: number;
+        message: string;
+        code: string;
+    };
+} | {
+    found: boolean;
+    error: null;
+};
+
+export { secretKeyCheck };

package/dist/libraries/backend/utils/secretKeyCheck.js

@@ -0,0 +1,42 @@
+"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/utils/secretKeyCheck.ts
+var secretKeyCheck_exports = {};
+__export(secretKeyCheck_exports, {
+  secretKeyCheck: () => secretKeyCheck
+});
+module.exports = __toCommonJS(secretKeyCheck_exports);
+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 };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  secretKeyCheck
+});

package/dist/libraries/backend/utils/secretKeyCheck.mjs

@@ -0,0 +1,6 @@
+import {
+  secretKeyCheck
+} from "../chunk-UNZHJTEY.mjs";
+export {
+  secretKeyCheck
+};

package/dist/libraries/backend/utils/withAuth.d.mts

@@ -0,0 +1,29 @@
+import { A as Autumn, C as CustomerData } from '../balancesTypes-Dk9mLKO8.mjs';
+import { AuthResult } from './AuthFunction.mjs';
+import 'zod/v4';
+import '../response-BBvvMvoC.mjs';
+
+declare const withAuth: <T extends {}>({ fn, requireCustomer, suppressLogs, }: {
+    fn: (args: {
+        autumn: Autumn;
+        body: any;
+        customer_id: string;
+        customer_data?: CustomerData;
+        pathParams?: Record<string, string>;
+        searchParams?: Record<string, string>;
+    }) => Promise<any>;
+    requireCustomer?: boolean;
+    suppressLogs?: boolean;
+}) => ({ autumn, body, path, getCustomer, pathParams, searchParams, }: {
+    autumn: Autumn;
+    body: any;
+    path: string;
+    getCustomer: () => AuthResult;
+    pathParams?: Record<string, string>;
+    searchParams?: Record<string, string>;
+}) => Promise<{
+    body: any;
+    statusCode: number;
+}>;
+
+export { withAuth };

package/dist/libraries/backend/utils/withAuth.d.ts

@@ -0,0 +1,29 @@
+import { A as Autumn, C as CustomerData } from '../balancesTypes-BrQjQCw3.js';
+import { AuthResult } from './AuthFunction.js';
+import 'zod/v4';
+import '../response-BBvvMvoC.js';
+
+declare const withAuth: <T extends {}>({ fn, requireCustomer, suppressLogs, }: {
+    fn: (args: {
+        autumn: Autumn;
+        body: any;
+        customer_id: string;
+        customer_data?: CustomerData;
+        pathParams?: Record<string, string>;
+        searchParams?: Record<string, string>;
+    }) => Promise<any>;
+    requireCustomer?: boolean;
+    suppressLogs?: boolean;
+}) => ({ autumn, body, path, getCustomer, pathParams, searchParams, }: {
+    autumn: Autumn;
+    body: any;
+    path: string;
+    getCustomer: () => AuthResult;
+    pathParams?: Record<string, string>;
+    searchParams?: Record<string, string>;
+}) => Promise<{
+    body: any;
+    statusCode: number;
+}>;
+
+export { withAuth };