@stardeckai/autumn-js 0.1.85

package/dist/next/server/auth/handleAuthProvider.js

@@ -0,0 +1,179 @@
+"use server";
+import { createSupabaseClient } from "./supabase-wrapper";
+import { getClerkModule } from "./clerk-wrapper";
+import { getNextHeadersAndCookies } from "./get-next-headers";
+const handleBetterAuth = async (options) => {
+  let betterAuth = options.instance;
+  if (!betterAuth) {
+    throw {
+      message: "BetterAuth instance is required",
+      code: "auth_instance_required"
+    };
+  }
+  const { headers } = await getNextHeadersAndCookies();
+  if (options.useOrg) {
+    try {
+      let org = await betterAuth.api.getFullOrganization({
+        headers: await headers()
+      });
+      let session = await betterAuth.api.getSession({
+        headers: await headers()
+      });
+      if (org) {
+        return {
+          customerId: org.id,
+          customerData: {
+            name: org.name,
+            email: session?.user?.email
+          }
+        };
+      }
+    } catch (error) {
+      throw {
+        message: "Failed to get/create organization",
+        code: "failed_to_create_organization"
+      };
+    }
+  }
+  if (options.useUser) {
+    try {
+      let session = await betterAuth.api.getSession({
+        headers: await headers()
+      });
+      if (session) {
+        return {
+          customerId: session.user.id,
+          customerData: {
+            name: session.user.name,
+            email: session.user.email
+          }
+        };
+      }
+    } catch (error) {
+      throw {
+        message: "Failed to get/create user",
+        code: "failed_to_create_user"
+      };
+    }
+  }
+  return null;
+};
+const handleClerk = async ({
+  options,
+  withCustomerData
+}) => {
+  const { verifyToken, createClerkClient } = await getClerkModule();
+  const { cookies } = await getNextHeadersAndCookies();
+  const cookieStore = await cookies();
+  let sessionToken = cookieStore.get("__session")?.value;
+  if (!sessionToken) {
+    console.warn("(Autumn) No clerk session token found");
+    return null;
+  }
+  const clerk = createClerkClient({
+    secretKey: process.env.CLERK_SECRET_KEY
+  });
+  const authData = await verifyToken(sessionToken, {
+    secretKey: process.env.CLERK_SECRET_KEY
+  });
+  let orgId = authData.org_id;
+  let userId = authData.sub;
+  if (options.useOrg) {
+    try {
+      if (orgId && withCustomerData) {
+        let org = await clerk.organizations.getOrganization({
+          organizationId: orgId
+        });
+        let email = null;
+        if (userId) {
+          let user = await clerk.users.getUser(userId);
+          email = user.primaryEmailAddress?.emailAddress;
+        }
+        return {
+          customerId: orgId,
+          customerData: {
+            name: org.name,
+            email
+          }
+        };
+      } else {
+        if (authData.orgId) {
+          return {
+            customerId: authData.orgId
+          };
+        }
+      }
+    } catch (error) {
+      throw {
+        message: `Failed to get/create clerk organization: ${error}`,
+        code: "failed_to_create_clerk_organization"
+      };
+    }
+  }
+  if (options.useUser && userId) {
+    try {
+      let user = await clerk.users.getUser(userId);
+      return {
+        customerId: userId,
+        customerData: {
+          name: user.fullName,
+          email: user.primaryEmailAddress?.emailAddress
+        }
+      };
+    } catch (error) {
+      throw {
+        message: `Failed to get/create clerk user: ${error}`,
+        code: "failed_to_create_clerk_user"
+      };
+    }
+  }
+  return null;
+};
+const handleSupabase = async (options) => {
+  let supabase;
+  supabase = await createSupabaseClient();
+  if (options.useOrg) {
+    console.warn("Supabase does not support organizations");
+  }
+  if (options.useUser) {
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return null;
+    }
+    return {
+      customerId: user?.id,
+      customerData: {
+        name: user?.user_metadata?.name,
+        email: user?.email
+      }
+    };
+  }
+  return null;
+};
+const handleAuthProvider = ({
+  authPlugin,
+  withCustomerData
+}) => {
+  let authProvider = authPlugin.provider;
+  switch (authProvider) {
+    case "better-auth":
+      return handleBetterAuth(authPlugin);
+    case "clerk":
+      return handleClerk({ options: authPlugin, withCustomerData });
+    case "supabase":
+      return handleSupabase(authPlugin);
+    default:
+      throw {
+        message: `Unsupported auth provider: ${authProvider}`,
+        code: "unsupported_auth_provider"
+      };
+  }
+};
+export {
+  handleAuthProvider,
+  handleBetterAuth,
+  handleClerk,
+  handleSupabase
+};

package/dist/next/server/auth/handleAuthProvider.mjs

@@ -0,0 +1,179 @@
+"use server";
+import { createSupabaseClient } from "./supabase-wrapper";
+import { getClerkModule } from "./clerk-wrapper";
+import { getNextHeadersAndCookies } from "./get-next-headers";
+const handleBetterAuth = async (options) => {
+  let betterAuth = options.instance;
+  if (!betterAuth) {
+    throw {
+      message: "BetterAuth instance is required",
+      code: "auth_instance_required"
+    };
+  }
+  const { headers } = await getNextHeadersAndCookies();
+  if (options.useOrg) {
+    try {
+      let org = await betterAuth.api.getFullOrganization({
+        headers: await headers()
+      });
+      let session = await betterAuth.api.getSession({
+        headers: await headers()
+      });
+      if (org) {
+        return {
+          customerId: org.id,
+          customerData: {
+            name: org.name,
+            email: session?.user?.email
+          }
+        };
+      }
+    } catch (error) {
+      throw {
+        message: "Failed to get/create organization",
+        code: "failed_to_create_organization"
+      };
+    }
+  }
+  if (options.useUser) {
+    try {
+      let session = await betterAuth.api.getSession({
+        headers: await headers()
+      });
+      if (session) {
+        return {
+          customerId: session.user.id,
+          customerData: {
+            name: session.user.name,
+            email: session.user.email
+          }
+        };
+      }
+    } catch (error) {
+      throw {
+        message: "Failed to get/create user",
+        code: "failed_to_create_user"
+      };
+    }
+  }
+  return null;
+};
+const handleClerk = async ({
+  options,
+  withCustomerData
+}) => {
+  const { verifyToken, createClerkClient } = await getClerkModule();
+  const { cookies } = await getNextHeadersAndCookies();
+  const cookieStore = await cookies();
+  let sessionToken = cookieStore.get("__session")?.value;
+  if (!sessionToken) {
+    console.warn("(Autumn) No clerk session token found");
+    return null;
+  }
+  const clerk = createClerkClient({
+    secretKey: process.env.CLERK_SECRET_KEY
+  });
+  const authData = await verifyToken(sessionToken, {
+    secretKey: process.env.CLERK_SECRET_KEY
+  });
+  let orgId = authData.org_id;
+  let userId = authData.sub;
+  if (options.useOrg) {
+    try {
+      if (orgId && withCustomerData) {
+        let org = await clerk.organizations.getOrganization({
+          organizationId: orgId
+        });
+        let email = null;
+        if (userId) {
+          let user = await clerk.users.getUser(userId);
+          email = user.primaryEmailAddress?.emailAddress;
+        }
+        return {
+          customerId: orgId,
+          customerData: {
+            name: org.name,
+            email
+          }
+        };
+      } else {
+        if (authData.orgId) {
+          return {
+            customerId: authData.orgId
+          };
+        }
+      }
+    } catch (error) {
+      throw {
+        message: `Failed to get/create clerk organization: ${error}`,
+        code: "failed_to_create_clerk_organization"
+      };
+    }
+  }
+  if (options.useUser && userId) {
+    try {
+      let user = await clerk.users.getUser(userId);
+      return {
+        customerId: userId,
+        customerData: {
+          name: user.fullName,
+          email: user.primaryEmailAddress?.emailAddress
+        }
+      };
+    } catch (error) {
+      throw {
+        message: `Failed to get/create clerk user: ${error}`,
+        code: "failed_to_create_clerk_user"
+      };
+    }
+  }
+  return null;
+};
+const handleSupabase = async (options) => {
+  let supabase;
+  supabase = await createSupabaseClient();
+  if (options.useOrg) {
+    console.warn("Supabase does not support organizations");
+  }
+  if (options.useUser) {
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return null;
+    }
+    return {
+      customerId: user?.id,
+      customerData: {
+        name: user?.user_metadata?.name,
+        email: user?.email
+      }
+    };
+  }
+  return null;
+};
+const handleAuthProvider = ({
+  authPlugin,
+  withCustomerData
+}) => {
+  let authProvider = authPlugin.provider;
+  switch (authProvider) {
+    case "better-auth":
+      return handleBetterAuth(authPlugin);
+    case "clerk":
+      return handleClerk({ options: authPlugin, withCustomerData });
+    case "supabase":
+      return handleSupabase(authPlugin);
+    default:
+      throw {
+        message: `Unsupported auth provider: ${authProvider}`,
+        code: "unsupported_auth_provider"
+      };
+  }
+};
+export {
+  handleAuthProvider,
+  handleBetterAuth,
+  handleClerk,
+  handleSupabase
+};

package/dist/next/server/auth/supabase-wrapper.d.mts

@@ -0,0 +1,3 @@
+declare function createSupabaseClient(): Promise<any>;
+
+export { createSupabaseClient };

package/dist/next/server/auth/supabase-wrapper.d.ts

@@ -0,0 +1,3 @@
+declare function createSupabaseClient(): Promise<any>;
+
+export { createSupabaseClient };

package/dist/next/server/auth/supabase-wrapper.js

@@ -0,0 +1,45 @@
+"use server";
+import { getNextHeadersAndCookies } from "./get-next-headers";
+async function createSupabaseClient() {
+  let createServerClient;
+  try {
+    let module = await import(
+      /* webpackIgnore: true */
+      "@supabase/ssr"
+    );
+    createServerClient = module.createServerClient;
+  } catch (error) {
+    throw {
+      message: `Failed to import @supabase/ssr. Please ensure you have the @supabase/ssr package installed.`,
+      code: "failed_to_import_supabase_ssr"
+    };
+  }
+  const { cookies } = await getNextHeadersAndCookies();
+  try {
+    const cookieStore = await cookies();
+    return createServerClient(
+      process.env.NEXT_PUBLIC_SUPABASE_URL,
+      process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
+      {
+        cookies: {
+          getAll() {
+            return cookieStore.getAll();
+          },
+          setAll(cookiesToSet) {
+            cookiesToSet.forEach(
+              ({ name, value, options }) => cookieStore.set(name, value, options)
+            );
+          }
+        }
+      }
+    );
+  } catch (error) {
+    throw {
+      message: `Failed to create supabase client. Error: ${error.message || error}`,
+      code: "failed_to_create_supabase_client"
+    };
+  }
+}
+export {
+  createSupabaseClient
+};

package/dist/next/server/auth/supabase-wrapper.mjs

@@ -0,0 +1,45 @@
+"use server";
+import { getNextHeadersAndCookies } from "./get-next-headers";
+async function createSupabaseClient() {
+  let createServerClient;
+  try {
+    let module = await import(
+      /* webpackIgnore: true */
+      "@supabase/ssr"
+    );
+    createServerClient = module.createServerClient;
+  } catch (error) {
+    throw {
+      message: `Failed to import @supabase/ssr. Please ensure you have the @supabase/ssr package installed.`,
+      code: "failed_to_import_supabase_ssr"
+    };
+  }
+  const { cookies } = await getNextHeadersAndCookies();
+  try {
+    const cookieStore = await cookies();
+    return createServerClient(
+      process.env.NEXT_PUBLIC_SUPABASE_URL,
+      process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
+      {
+        cookies: {
+          getAll() {
+            return cookieStore.getAll();
+          },
+          setAll(cookiesToSet) {
+            cookiesToSet.forEach(
+              ({ name, value, options }) => cookieStore.set(name, value, options)
+            );
+          }
+        }
+      }
+    );
+  } catch (error) {
+    throw {
+      message: `Failed to create supabase client. Error: ${error.message || error}`,
+      code: "failed_to_create_supabase_client"
+    };
+  }
+}
+export {
+  createSupabaseClient
+};

package/dist/next/server/auth/withNextAuth.d.mts

@@ -0,0 +1,16 @@
+import { C as CustomerData } from '../cusTypes-C7g7DT5P.mjs';
+import 'zod/v4';
+
+declare const withAuth: <T extends {
+    customerId?: string;
+    customerData?: CustomerData;
+    authProvider?: string;
+}>({ fn, withCustomerData, requireCustomer, }: {
+    fn: (args: T) => Promise<any>;
+    withCustomerData?: boolean;
+    requireCustomer?: boolean;
+}) => (args: Omit<T, "customerId"> & {
+    encryptedCustomerId?: string;
+}, request?: Request) => Promise<any>;
+
+export { withAuth };

package/dist/next/server/auth/withNextAuth.d.ts

@@ -0,0 +1,16 @@
+import { C as CustomerData } from '../cusTypes-C7g7DT5P.js';
+import 'zod/v4';
+
+declare const withAuth: <T extends {
+    customerId?: string;
+    customerData?: CustomerData;
+    authProvider?: string;
+}>({ fn, withCustomerData, requireCustomer, }: {
+    fn: (args: T) => Promise<any>;
+    withCustomerData?: boolean;
+    requireCustomer?: boolean;
+}) => (args: Omit<T, "customerId"> & {
+    encryptedCustomerId?: string;
+}, request?: Request) => Promise<any>;
+
+export { withAuth };

package/dist/next/server/auth/withNextAuth.js

@@ -0,0 +1,42 @@
+"use server";
+import { decryptData } from "../../../utils/encryptUtils";
+import { handleAuthProvider } from "./handleAuthProvider";
+import { getAuthPlugin } from "./authPlugin";
+const noCustomerIdError = () => {
+  return {
+    data: null,
+    error: {
+      message: "Customer ID is required",
+      code: "no_customer_id"
+    }
+  };
+};
+const withAuth = ({
+  fn,
+  withCustomerData = false,
+  requireCustomer = true
+}) => {
+  return async (args, request) => {
+    let customerId = null;
+    let customerData = args.customerData || void 0;
+    const authConfig = getAuthPlugin();
+    if (authConfig?.provider) {
+      let result = await handleAuthProvider({
+        authPlugin: authConfig,
+        withCustomerData
+      });
+      customerId = result?.customerId;
+      customerData = result?.customerData || void 0;
+    } else {
+      let encryptedCustomerId = args.encryptedCustomerId;
+      customerId = encryptedCustomerId ? decryptData(encryptedCustomerId) : null;
+    }
+    if (!customerId && requireCustomer) {
+      return noCustomerIdError();
+    }
+    return fn({ ...args, customerId, customerData });
+  };
+};
+export {
+  withAuth
+};

package/dist/next/server/auth/withNextAuth.mjs

@@ -0,0 +1,42 @@
+"use server";
+import { decryptData } from "../../../utils/encryptUtils";
+import { handleAuthProvider } from "./handleAuthProvider";
+import { getAuthPlugin } from "./authPlugin";
+const noCustomerIdError = () => {
+  return {
+    data: null,
+    error: {
+      message: "Customer ID is required",
+      code: "no_customer_id"
+    }
+  };
+};
+const withAuth = ({
+  fn,
+  withCustomerData = false,
+  requireCustomer = true
+}) => {
+  return async (args, request) => {
+    let customerId = null;
+    let customerData = args.customerData || void 0;
+    const authConfig = getAuthPlugin();
+    if (authConfig?.provider) {
+      let result = await handleAuthProvider({
+        authPlugin: authConfig,
+        withCustomerData
+      });
+      customerId = result?.customerId;
+      customerData = result?.customerData || void 0;
+    } else {
+      let encryptedCustomerId = args.encryptedCustomerId;
+      customerId = encryptedCustomerId ? decryptData(encryptedCustomerId) : null;
+    }
+    if (!customerId && requireCustomer) {
+      return noCustomerIdError();
+    }
+    return fn({ ...args, customerId, customerData });
+  };
+};
+export {
+  withAuth
+};

package/dist/next/server/componentActions.d.mts

@@ -0,0 +1,12 @@
+import { C as CustomerData } from './cusTypes-C7g7DT5P.mjs';
+import 'zod/v4';
+
+declare const getPricingTableAction: (args: Omit<{
+    customerId?: string;
+    customerData?: CustomerData;
+    authProvider?: string;
+}, "customerId"> & {
+    encryptedCustomerId?: string;
+}, request?: Request) => Promise<any>;
+
+export { getPricingTableAction };

package/dist/next/server/componentActions.d.ts

@@ -0,0 +1,12 @@
+import { C as CustomerData } from './cusTypes-C7g7DT5P.js';
+import 'zod/v4';
+
+declare const getPricingTableAction: (args: Omit<{
+    customerId?: string;
+    customerData?: CustomerData;
+    authProvider?: string;
+}, "customerId"> & {
+    encryptedCustomerId?: string;
+}, request?: Request) => Promise<any>;
+
+export { getPricingTableAction };

package/dist/next/server/componentActions.js

@@ -0,0 +1,21 @@
+"use server";
+import { withAuth } from "./auth/withNextAuth";
+import { createAutumnClient } from "./cusActions";
+import { fetchPricingTable } from "../../sdk";
+import { toServerResponse } from "./utils";
+const getPricingTableAction = withAuth({
+  fn: async ({ customerId }) => {
+    let autumn = createAutumnClient();
+    const res = await fetchPricingTable({
+      instance: autumn,
+      params: {
+        customer_id: customerId
+      }
+    });
+    return toServerResponse(res);
+  },
+  requireCustomer: false
+});
+export {
+  getPricingTableAction
+};

package/dist/next/server/componentActions.mjs

@@ -0,0 +1,21 @@
+"use server";
+import { withAuth } from "./auth/withNextAuth";
+import { createAutumnClient } from "./cusActions";
+import { fetchPricingTable } from "../../sdk";
+import { toServerResponse } from "./utils";
+const getPricingTableAction = withAuth({
+  fn: async ({ customerId }) => {
+    let autumn = createAutumnClient();
+    const res = await fetchPricingTable({
+      instance: autumn,
+      params: {
+        customer_id: customerId
+      }
+    });
+    return toServerResponse(res);
+  },
+  requireCustomer: false
+});
+export {
+  getPricingTableAction
+};