autumn-js 0.1.22 → 0.1.24

package/dist/libraries/react/index.d.ts

@@ -433,9 +433,10 @@ interface RedeemReferralCodeResult {
     reward_id: string;
 }
 
-declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, betterAuthUrl, headers, convexApi, }: {
+declare const ReactAutumnProvider: ({ children, getBearerToken, convex, backendUrl, customerData, includeCredentials, betterAuthUrl, headers, convexApi, }: {
     children: React.ReactNode;
-    getBearerToken?: () => Promise<string | null | undefined>;
+    getBearerToken?: () => Promise<string | null>;
+    convex?: any;
     backendUrl?: string;
     customerData?: CustomerData;
     includeCredentials?: boolean;
@@ -711,21 +712,7 @@ declare const useEntity: (entityId: string | null, params?: GetEntityParams) =>
         data: CheckResult;
         error: null;
     };
-    attach: (params: AttachParams) => Promise<Result<{
-        customer_id: string;
-        product_ids: string[];
-        code: string;
-        message: string;
-        checkout_url?: string | undefined;
-        customer_data?: any;
-        invoice?: {
-            status: string;
-            stripe_id: string;
-            hosted_invoice_url: string | null;
-            total: number;
-            currency: string;
-        } | undefined;
-    } | CheckResult, AutumnError>>;
+    attach: (params: AttachParams) => Promise<any>;
     cancel: (params: CancelParams) => AutumnPromise<{
         success: boolean;
         customer_id: string;

package/dist/libraries/react/index.js

@@ -1000,6 +1000,31 @@ var CheckoutParamsSchema = import_v47.z.object({
   reward: import_v47.z.string().optional()
 });
 
+// src/sdk/features/featureTypes.ts
+var import_zod = require("zod");
+var FeatureType = /* @__PURE__ */ ((FeatureType2) => {
+  FeatureType2["Boolean"] = "boolean";
+  FeatureType2["SingleUse"] = "single_use";
+  FeatureType2["ContinuousUse"] = "continuous_use";
+  FeatureType2["CreditSystem"] = "credit_system";
+  return FeatureType2;
+})(FeatureType || {});
+var FeatureSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string().nullish(),
+  type: import_zod.z.nativeEnum(FeatureType),
+  display: import_zod.z.object({
+    singular: import_zod.z.string(),
+    plural: import_zod.z.string()
+  }).nullish(),
+  credit_schema: import_zod.z.array(
+    import_zod.z.object({
+      metered_feature_id: import_zod.z.string(),
+      credit_cost: import_zod.z.number()
+    })
+  ).nullish()
+});
+
 // src/libraries/react/errorUtils/logFetchError.ts
 var logFetchError = ({
   method,
@@ -1209,8 +1234,10 @@ var AutumnClient = class {
           `[Autumn] To disable this warning, you can set includeCredentials={${corsResult.includeCredentials ? "true" : "false"}} in <AutumnProvider />`
         );
         this.includeCredentials = corsResult.includeCredentials;
+        return corsResult.includeCredentials || false;
       }
-      return corsResult.includeCredentials || false;
+      console.warn(`[Autumn] CORS detection failed, defaulting to false`);
+      return false;
     } catch (error) {
       console.error(`[Autumn] Error detecting CORS: ${error.message}`);
       return false;
@@ -1714,7 +1741,7 @@ var getCusFeature = ({
   requiredBalance = 1
 }) => {
   let cusFeature = customer.features[featureId];
-  if (cusFeature && typeof cusFeature.balance === "number" && cusFeature.balance >= (requiredBalance ?? 1)) {
+  if (cusFeature && typeof cusFeature.balance === "number" && cusFeature.balance >= requiredBalance) {
     return {
       cusFeature,
       requiredBalance
@@ -1760,7 +1787,10 @@ var handleFeatureCheck = ({
     featureId: params.featureId,
     ...params.requiredBalance ? { requiredBalance: params.requiredBalance } : {}
   });
-  let allowed = getFeatureAllowed({ cusFeature, requiredBalance });
+  let allowed = getFeatureAllowed({
+    cusFeature,
+    requiredBalance: requiredBalance ?? 1
+  });
   let result = {
     allowed,
     feature_id: cusFeature?.id ?? params.featureId,
@@ -2013,6 +2043,324 @@ function BaseAutumnProvider({
   );
 }
 
+// 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.createCustomer,
+        params
+      );
+      return result;
+    } catch (error) {
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "convex_action_failed"
+        })
+      };
+    }
+  }
+  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)) {
+          throw new Error(
+            "Passing an array of entities to createEntity() is not supported for Convex"
+          );
+        } 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 (entityId, args) => {
+      try {
+        const result = await this.convex.action(this.convexApi.getEntity, {
+          entityId,
+          ...args
+        });
+        return result;
+      } catch (error) {
+        console.error("Error fetching entity: ", 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"
+          })
+        };
+      }
+    }
+  };
+};
+
 // src/libraries/react/ReactAutumnProvider.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var getBackendUrl = (backendUrl) => {
@@ -2027,6 +2375,7 @@ var getBackendUrl = (backendUrl) => {
 var ReactAutumnProvider = ({
   children,
   getBearerToken,
+  convex,
   backendUrl,
   customerData,
   includeCredentials,
@@ -2034,7 +2383,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,