autumn-js 0.1.21 → 0.1.23

package/dist/libraries/react/{chunk-NYQF7NO3.mjs → chunk-O7IKBONA.mjs}

@@ -3,7 +3,7 @@
 import {
   AutumnContext,
   useAutumnContext
-} from "./chunk-PN6WKUSX.mjs";
+} from "./chunk-MUZHFEMO.mjs";
 
 // src/libraries/react/hooks/usePaywall.tsx
 import useSWR from "swr";

package/dist/libraries/react/{chunk-OCP7PVSZ.mjs → chunk-PZVVV3LN.mjs}

@@ -2,13 +2,16 @@
 
 import {
   BaseAutumnProvider
-} from "./chunk-Y5S2HOFE.mjs";
+} from "./chunk-MYRJW7LW.mjs";
 import {
   AutumnContext
-} from "./chunk-PN6WKUSX.mjs";
+} from "./chunk-MUZHFEMO.mjs";
+import {
+  ConvexAutumnClient
+} from "./chunk-ZH7N5FIC.mjs";
 import {
   AutumnClient
-} from "./chunk-JNJRQ5DT.mjs";
+} from "./chunk-NBVPBAGX.mjs";
 
 // src/libraries/react/ReactAutumnProvider.tsx
 import { jsx } from "react/jsx-runtime";
@@ -24,6 +27,7 @@ var getBackendUrl = (backendUrl) => {
 var ReactAutumnProvider = ({
   children,
   getBearerToken,
+  convex,
   backendUrl,
   customerData,
   includeCredentials,
@@ -31,7 +35,13 @@ var ReactAutumnProvider = ({
   headers,
   convexApi
 }) => {
-  let client = new AutumnClient({
+  let client = convexApi ? new ConvexAutumnClient({
+    convex,
+    convexApi,
+    customerData,
+    headers,
+    getBearerToken
+  }) : new AutumnClient({
     backendUrl: getBackendUrl(backendUrl),
     getBearerToken,
     customerData,

package/dist/libraries/react/{chunk-JWT4MREG.mjs → chunk-QYW6U2NR.mjs}

@@ -3,13 +3,13 @@
 import {
   handleCheck,
   openDialog
-} from "./chunk-S744ECJP.mjs";
+} from "./chunk-COGRLJH2.mjs";
 import {
   useAutumnBase
-} from "./chunk-NFVAFRF6.mjs";
+} from "./chunk-2SFUXGFK.mjs";
 import {
   useAutumnContext
-} from "./chunk-PN6WKUSX.mjs";
+} from "./chunk-MUZHFEMO.mjs";
 
 // src/libraries/react/hooks/useEntityBase.tsx
 import useSWR from "swr";

package/dist/libraries/react/{chunk-74HNY7BP.mjs → chunk-UMG2RCCT.mjs}

@@ -2,11 +2,11 @@
 
 import {
   usePricingTableBase
-} from "./chunk-HBJDIEEJ.mjs";
+} from "./chunk-4WAFPXBN.mjs";
 import {
   AutumnContext,
   useAutumnContext
-} from "./chunk-PN6WKUSX.mjs";
+} from "./chunk-MUZHFEMO.mjs";
 
 // src/libraries/react/hooks/usePricingTable.tsx
 var usePricingTable = (params) => {

package/dist/libraries/react/{chunk-KHIB6HEY.mjs → chunk-WRVDJJBE.mjs}

@@ -2,10 +2,10 @@
 
 import {
   useEntityBase
-} from "./chunk-JWT4MREG.mjs";
+} from "./chunk-QYW6U2NR.mjs";
 import {
   AutumnContext
-} from "./chunk-PN6WKUSX.mjs";
+} from "./chunk-MUZHFEMO.mjs";
 
 // src/libraries/react/hooks/useEntity.tsx
 var useEntity = (entityId, params) => {

package/dist/libraries/react/chunk-ZH7N5FIC.mjs

@@ -0,0 +1,324 @@
+"use client";
+
+import {
+  AutumnError
+} from "./chunk-KUFNEIRV.mjs";
+
+// src/libraries/react/client/ConvexAutumnClient.tsx
+var ConvexAutumnClient = class {
+  convexApi;
+  convex;
+  // protected readonly convexClient: ConvexHttpClient;
+  customerData;
+  headers;
+  backendUrl = void 0;
+  prefix = "/api/convex";
+  getBearerToken;
+  // Stub implementations for HTTP-specific methods that the interface requires
+  async detectCors() {
+    return {
+      valid: true,
+      includeCredentials: false
+    };
+  }
+  async shouldIncludeCredentials() {
+    return false;
+  }
+  async getHeaders() {
+    return { "Content-Type": "application/json" };
+  }
+  async handleFetch() {
+    throw new Error("HTTP methods not supported in Convex mode");
+  }
+  async post() {
+    throw new Error("HTTP methods not supported in Convex mode");
+  }
+  async get() {
+    throw new Error("HTTP methods not supported in Convex mode");
+  }
+  async delete() {
+    throw new Error("HTTP methods not supported in Convex mode");
+  }
+  constructor({
+    convexApi,
+    customerData,
+    headers,
+    getBearerToken,
+    convex
+  }) {
+    this.convex = convex;
+    this.convexApi = convexApi;
+    this.getBearerToken = getBearerToken;
+    this.customerData = customerData;
+    this.headers = headers;
+  }
+  async createCustomer(params) {
+    try {
+      const result = await this.convex.action(this.convexApi.fetchCustomer);
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  }
+  // Deprecated, don't need to implement
+  async getPricingTable() {
+    return {
+      data: null,
+      error: new AutumnError({
+        message: "getPricingTable not yet implemented for Convex",
+        code: "not_implemented"
+      })
+    };
+  }
+  // Core methods that wrap Convex actions
+  attach = async (args) => {
+    try {
+      const { dialog, ...backendArgs } = args;
+      const result = await this.convex.action(
+        this.convexApi.attach,
+        backendArgs
+      );
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  checkout = async (args) => {
+    try {
+      const { dialog, ...backendArgs } = args;
+      const result = await this.convex.action(
+        this.convexApi.checkout,
+        backendArgs
+      );
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  cancel = async (args) => {
+    try {
+      const result = await this.convex.action(this.convexApi.cancel, args);
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  check = async (args) => {
+    try {
+      const result = await this.convex.action(this.convexApi.check, args);
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  track = async (args) => {
+    try {
+      const result = await this.convex.action(this.convexApi.track, args);
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  openBillingPortal = async (args) => {
+    try {
+      const result = await this.convex.action(this.convexApi.billingPortal, {
+        ...args,
+        openInNewTab: void 0
+      });
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  setupPayment = async (args) => {
+    try {
+      const result = await this.convex.action(
+        this.convexApi.setupPayment,
+        args
+      );
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  query = async (args) => {
+    try {
+      const result = await this.convex.action(this.convexApi.query, args);
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  };
+  entities = {
+    create: async (args) => {
+      try {
+        if (Array.isArray(args)) {
+          const entityArgs = { entities: args };
+          const result = await this.convex.action(
+            this.convexApi.createEntities,
+            entityArgs
+          );
+          return result;
+        } else {
+          const result = await this.convex.action(
+            this.convexApi.createEntity,
+            args
+          );
+          return result;
+        }
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    },
+    get: async (args) => {
+      try {
+        const result = await this.convex.action(this.convexApi.getEntity, args);
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    },
+    delete: async (args) => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.deleteEntity,
+          args
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    }
+  };
+  referrals = {
+    createCode: async (args) => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.createReferralCode,
+          args
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    },
+    redeemCode: async (args) => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.redeemReferralCode,
+          args
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    }
+  };
+  products = {
+    list: async () => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.listProducts,
+          {}
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    }
+  };
+};
+
+export {
+  ConvexAutumnClient
+};

package/dist/libraries/react/{chunk-PDPOI2J7.mjs → chunk-ZYTMSYY3.mjs}

@@ -3,23 +3,9 @@
 import {
   getPricingTableContent
 } from "./chunk-URQMBRFZ.mjs";
-import {
-  getCheckoutContent
-} from "./chunk-BLM4DAAR.mjs";
 import {
   getPaywallContent
 } from "./chunk-I5ZGIAIX.mjs";
-import {
-  Input
-} from "./chunk-GUM4HIGI.mjs";
-import {
-  Popover,
-  PopoverContent,
-  PopoverTrigger
-} from "./chunk-X6FMCHSB.mjs";
-import {
-  Switch
-} from "./chunk-WUEXMQIT.mjs";
 import {
   Accordion,
   AccordionContent,
@@ -35,24 +21,38 @@ import {
   DialogContent,
   DialogFooter,
   DialogTitle
-} from "./chunk-YE6KQQS7.mjs";
+} from "./chunk-UYZX3KX2.mjs";
 import {
   ArrowRight,
   ChevronDown,
   LoaderCircle
 } from "./chunk-2OHJ6PS6.mjs";
 import {
-  useCustomer
-} from "./chunk-XUS3TD2B.mjs";
+  Input
+} from "./chunk-GUM4HIGI.mjs";
 import {
-  usePaywall
-} from "./chunk-NYQF7NO3.mjs";
+  Popover,
+  PopoverContent,
+  PopoverTrigger
+} from "./chunk-5KZSH7JF.mjs";
 import {
-  usePricingTable
-} from "./chunk-74HNY7BP.mjs";
+  Switch
+} from "./chunk-WUEXMQIT.mjs";
+import {
+  getCheckoutContent
+} from "./chunk-BLM4DAAR.mjs";
 import {
   cn
 } from "./chunk-4J6OC4ZQ.mjs";
+import {
+  useCustomer
+} from "./chunk-6KINUP6L.mjs";
+import {
+  usePaywall
+} from "./chunk-O7IKBONA.mjs";
+import {
+  usePricingTable
+} from "./chunk-UMG2RCCT.mjs";
 import {
   loadingStyles,
   spinnerStyles

package/dist/libraries/react/client/ConvexAutumnClient.d.mts

@@ -0,0 +1,76 @@
+import { A as AutumnError } from '../error-DHbclCVh.mjs';
+import { C as CustomerData, a as CreateCustomerParams } from '../cusTypes-DynqPCZH.mjs';
+import { P as Product } from '../prodTypes-C8xRoBP7.mjs';
+import { A as AutumnPromise } from '../entTypes-DjasDDYh.mjs';
+import { I as IAutumnClient } from '../ReactAutumnClient--zmCg7U8.mjs';
+import 'zod/v4';
+import './types/clientEntTypes.mjs';
+import './types/clientGenTypes.mjs';
+import '../genTypes-DdYlVEah.mjs';
+import '../attachTypes-DJIr5ldB.mjs';
+
+interface ErrorResponse {
+    message: string;
+    code: string;
+}
+type OmitCustomerType = "id" | "name" | "email" | "fingerprint" | "customer_id";
+interface ConvexAutumnClientConfig {
+    convexApi: any;
+    customerData?: CustomerData;
+    headers?: Record<string, string>;
+    getBearerToken?: () => Promise<string | null>;
+    convex: any;
+}
+declare class ConvexAutumnClient implements IAutumnClient {
+    protected readonly convexApi: any;
+    protected readonly convex: any;
+    readonly customerData?: CustomerData;
+    readonly headers?: Record<string, string>;
+    readonly backendUrl?: string;
+    readonly prefix: string;
+    readonly getBearerToken?: () => Promise<string | null>;
+    detectCors(): Promise<{
+        valid: boolean;
+        includeCredentials: boolean | undefined;
+    }>;
+    shouldIncludeCredentials(): Promise<boolean>;
+    getHeaders(): Promise<{
+        "Content-Type": string;
+    }>;
+    handleFetch(): Promise<void>;
+    post(): Promise<void>;
+    get(): Promise<void>;
+    delete(): Promise<void>;
+    constructor({ convexApi, customerData, headers, getBearerToken, convex, }: ConvexAutumnClientConfig);
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<any>;
+    getPricingTable(): Promise<{
+        data: null;
+        error: AutumnError;
+    }>;
+    attach: (args: any) => Promise<any>;
+    checkout: (args: any) => Promise<any>;
+    cancel: (args: any) => Promise<any>;
+    check: (args: any) => Promise<any>;
+    track: (args: any) => Promise<any>;
+    openBillingPortal: (args: any) => Promise<any>;
+    setupPayment: (args: any) => Promise<any>;
+    query: (args: any) => Promise<any>;
+    entities: {
+        create: (args: any) => Promise<any>;
+        get: (args: any) => Promise<any>;
+        delete: (args: any) => Promise<any>;
+    };
+    referrals: {
+        createCode: (args: any) => Promise<any>;
+        redeemCode: (args: any) => Promise<any>;
+    };
+    products: {
+        list: () => AutumnPromise<{
+            list: Product[];
+        }>;
+    };
+}
+
+export { ConvexAutumnClient, type ConvexAutumnClientConfig, type ErrorResponse, type OmitCustomerType };

package/dist/libraries/react/client/ConvexAutumnClient.d.ts

@@ -0,0 +1,76 @@
+import { A as AutumnError } from '../error-DHbclCVh.js';
+import { C as CustomerData, a as CreateCustomerParams } from '../cusTypes-CEb_KwPo.js';
+import { P as Product } from '../prodTypes-C8xRoBP7.js';
+import { A as AutumnPromise } from '../entTypes--Y-4T20Y.js';
+import { I as IAutumnClient } from '../ReactAutumnClient-XuVllEBP.js';
+import 'zod/v4';
+import './types/clientEntTypes.js';
+import './types/clientGenTypes.js';
+import '../genTypes-aPPwPimh.js';
+import '../attachTypes-DVF4f7Hw.js';
+
+interface ErrorResponse {
+    message: string;
+    code: string;
+}
+type OmitCustomerType = "id" | "name" | "email" | "fingerprint" | "customer_id";
+interface ConvexAutumnClientConfig {
+    convexApi: any;
+    customerData?: CustomerData;
+    headers?: Record<string, string>;
+    getBearerToken?: () => Promise<string | null>;
+    convex: any;
+}
+declare class ConvexAutumnClient implements IAutumnClient {
+    protected readonly convexApi: any;
+    protected readonly convex: any;
+    readonly customerData?: CustomerData;
+    readonly headers?: Record<string, string>;
+    readonly backendUrl?: string;
+    readonly prefix: string;
+    readonly getBearerToken?: () => Promise<string | null>;
+    detectCors(): Promise<{
+        valid: boolean;
+        includeCredentials: boolean | undefined;
+    }>;
+    shouldIncludeCredentials(): Promise<boolean>;
+    getHeaders(): Promise<{
+        "Content-Type": string;
+    }>;
+    handleFetch(): Promise<void>;
+    post(): Promise<void>;
+    get(): Promise<void>;
+    delete(): Promise<void>;
+    constructor({ convexApi, customerData, headers, getBearerToken, convex, }: ConvexAutumnClientConfig);
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<any>;
+    getPricingTable(): Promise<{
+        data: null;
+        error: AutumnError;
+    }>;
+    attach: (args: any) => Promise<any>;
+    checkout: (args: any) => Promise<any>;
+    cancel: (args: any) => Promise<any>;
+    check: (args: any) => Promise<any>;
+    track: (args: any) => Promise<any>;
+    openBillingPortal: (args: any) => Promise<any>;
+    setupPayment: (args: any) => Promise<any>;
+    query: (args: any) => Promise<any>;
+    entities: {
+        create: (args: any) => Promise<any>;
+        get: (args: any) => Promise<any>;
+        delete: (args: any) => Promise<any>;
+    };
+    referrals: {
+        createCode: (args: any) => Promise<any>;
+        redeemCode: (args: any) => Promise<any>;
+    };
+    products: {
+        list: () => AutumnPromise<{
+            list: Product[];
+        }>;
+    };
+}
+
+export { ConvexAutumnClient, type ConvexAutumnClientConfig, type ErrorResponse, type OmitCustomerType };