autumn-js 0.1.21 → 0.1.23

package/dist/libraries/react/ReactAutumnProvider.js

@@ -967,6 +967,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,
@@ -1176,8 +1201,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;
@@ -1680,6 +1707,13 @@ var getCusFeature = ({
   featureId,
   requiredBalance = 1
 }) => {
+  let cusFeature = customer.features[featureId];
+  if (cusFeature && typeof cusFeature.balance === "number" && cusFeature.balance >= requiredBalance) {
+    return {
+      cusFeature,
+      requiredBalance
+    };
+  }
   let creditSchema = Object.values(customer.features).find(
     (f) => f.credit_schema && f.credit_schema.some((c) => c.feature_id === featureId)
   );
@@ -1688,7 +1722,7 @@ var getCusFeature = ({
       (c) => c.feature_id === featureId
     );
     return {
-      feature: creditSchema,
+      cusFeature: creditSchema,
       requiredBalance: schemaItem.credit_amount * requiredBalance
     };
   }
@@ -1720,10 +1754,15 @@ var handleFeatureCheck = ({
     featureId: params.featureId,
     ...params.requiredBalance ? { requiredBalance: params.requiredBalance } : {}
   });
-  let allowed = getFeatureAllowed({ cusFeature, requiredBalance });
+  console.log("Cus Feature", cusFeature);
+  console.log("Required Balance", requiredBalance);
+  let allowed = getFeatureAllowed({
+    cusFeature,
+    requiredBalance: requiredBalance ?? 1
+  });
   let result = {
     allowed,
-    feature_id: params.featureId,
+    feature_id: cusFeature?.id ?? params.featureId,
     customer_id: isEntity ? customer.customer_id : customer.id,
     required_balance: requiredBalance,
     ...cusFeature
@@ -1973,6 +2012,321 @@ 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.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"
+          })
+        };
+      }
+    }
+  };
+};
+
 // src/libraries/react/ReactAutumnProvider.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var getBackendUrl = (backendUrl) => {
@@ -1987,6 +2341,7 @@ var getBackendUrl = (backendUrl) => {
 var ReactAutumnProvider = ({
   children,
   getBearerToken,
+  convex,
   backendUrl,
   customerData,
   includeCredentials,
@@ -1994,7 +2349,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/ReactAutumnProvider.mjs

@@ -2,25 +2,26 @@
 
 import {
   ReactAutumnProvider
-} from "./chunk-OCP7PVSZ.mjs";
-import "./chunk-Y5S2HOFE.mjs";
+} from "./chunk-PZVVV3LN.mjs";
+import "./chunk-MYRJW7LW.mjs";
 import "./chunk-RFSQBGLO.mjs";
-import "./chunk-VELC6P5V.mjs";
-import "./chunk-S744ECJP.mjs";
-import "./chunk-NFVAFRF6.mjs";
-import "./chunk-HBJDIEEJ.mjs";
-import "./chunk-PN6WKUSX.mjs";
-import "./chunk-JNJRQ5DT.mjs";
-import "./chunk-ABJEE3UK.mjs";
-import "./chunk-ZF2HUCN6.mjs";
+import "./chunk-54IJL24F.mjs";
+import "./chunk-COGRLJH2.mjs";
+import "./chunk-2SFUXGFK.mjs";
+import "./chunk-4WAFPXBN.mjs";
+import "./chunk-MUZHFEMO.mjs";
+import "./chunk-ZH7N5FIC.mjs";
+import "./chunk-NBVPBAGX.mjs";
 import "./chunk-BCLKTVUX.mjs";
 import "./chunk-V575SGOW.mjs";
 import "./chunk-ZV4RPZTM.mjs";
-import "./chunk-KQT5G3HT.mjs";
 import "./chunk-JVCOY7ZL.mjs";
 import "./chunk-CIBQ4BJU.mjs";
+import "./chunk-KUFNEIRV.mjs";
 import "./chunk-VTGR7VVK.mjs";
 import "./chunk-WFFVOEUG.mjs";
+import "./chunk-ZF2HUCN6.mjs";
+import "./chunk-KQT5G3HT.mjs";
 export {
   ReactAutumnProvider
 };

package/dist/libraries/react/{attachTypes-gI6T0O95.d.mts → attachTypes-DJIr5ldB.d.mts}

@@ -1,4 +1,4 @@
-import { a as ProductItem, P as Product } from './prodTypes-B8NdKyKo.mjs';
+import { c as ProductItem, P as Product } from './prodTypes-C8xRoBP7.mjs';
 import { z } from 'zod/v4';
 
 declare const AttachFeatureOptionsSchema: z.ZodObject<{

package/dist/libraries/react/{attachTypes-DoCshKK6.d.ts → attachTypes-DVF4f7Hw.d.ts}

@@ -1,4 +1,4 @@
-import { a as ProductItem, P as Product } from './prodTypes-B8NdKyKo.js';
+import { c as ProductItem, P as Product } from './prodTypes-C8xRoBP7.js';
 import { z } from 'zod/v4';
 
 declare const AttachFeatureOptionsSchema: z.ZodObject<{

package/dist/libraries/react/{chunk-NFVAFRF6.mjs → chunk-2SFUXGFK.mjs}

@@ -2,7 +2,7 @@
 
 import {
   usePricingTableBase
-} from "./chunk-HBJDIEEJ.mjs";
+} from "./chunk-4WAFPXBN.mjs";
 
 // src/libraries/react/hooks/helpers/useAutumnBase.tsx
 var useAutumnBase = ({

package/dist/libraries/react/{chunk-HBJDIEEJ.mjs → chunk-4WAFPXBN.mjs}

@@ -2,7 +2,7 @@
 
 import {
   AutumnError
-} from "./chunk-ABJEE3UK.mjs";
+} from "./chunk-KUFNEIRV.mjs";
 
 // src/libraries/react/hooks/usePricingTableBase.tsx
 import useSWR from "swr";

package/dist/libraries/react/{chunk-VELC6P5V.mjs → chunk-54IJL24F.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/useCustomerBase.tsx
 import useSWR from "swr";

package/dist/libraries/react/{chunk-AS4XOUEI.mjs → chunk-65UX5FJ5.mjs}

@@ -3,10 +3,10 @@
 import {
   AutumnContext,
   useAutumnContext
-} from "./chunk-PN6WKUSX.mjs";
+} from "./chunk-MUZHFEMO.mjs";
 import {
   AutumnError
-} from "./chunk-ABJEE3UK.mjs";
+} from "./chunk-KUFNEIRV.mjs";
 
 // src/libraries/react/hooks/useAnalytics.tsx
 import useSWR from "swr";

package/dist/libraries/react/{chunk-XUS3TD2B.mjs → chunk-6KINUP6L.mjs}

@@ -2,10 +2,10 @@
 
 import {
   useCustomerBase
-} from "./chunk-VELC6P5V.mjs";
+} from "./chunk-54IJL24F.mjs";
 import {
   AutumnContext
-} from "./chunk-PN6WKUSX.mjs";
+} from "./chunk-MUZHFEMO.mjs";
 
 // src/libraries/react/hooks/useCustomer.tsx
 var useCustomer = (params) => {

package/dist/libraries/react/{chunk-S744ECJP.mjs → chunk-COGRLJH2.mjs}

@@ -2,7 +2,7 @@
 
 import {
   CheckFeatureResultSchema
-} from "./chunk-ABJEE3UK.mjs";
+} from "./chunk-KUFNEIRV.mjs";
 
 // src/libraries/react/hooks/helpers/handleCheck.ts
 var getCusFeature = ({
@@ -10,6 +10,13 @@ var getCusFeature = ({
   featureId,
   requiredBalance = 1
 }) => {
+  let cusFeature = customer.features[featureId];
+  if (cusFeature && typeof cusFeature.balance === "number" && cusFeature.balance >= requiredBalance) {
+    return {
+      cusFeature,
+      requiredBalance
+    };
+  }
   let creditSchema = Object.values(customer.features).find(
     (f) => f.credit_schema && f.credit_schema.some((c) => c.feature_id === featureId)
   );
@@ -18,7 +25,7 @@ var getCusFeature = ({
       (c) => c.feature_id === featureId
     );
     return {
-      feature: creditSchema,
+      cusFeature: creditSchema,
       requiredBalance: schemaItem.credit_amount * requiredBalance
     };
   }
@@ -50,10 +57,15 @@ var handleFeatureCheck = ({
     featureId: params.featureId,
     ...params.requiredBalance ? { requiredBalance: params.requiredBalance } : {}
   });
-  let allowed = getFeatureAllowed({ cusFeature, requiredBalance });
+  console.log("Cus Feature", cusFeature);
+  console.log("Required Balance", requiredBalance);
+  let allowed = getFeatureAllowed({
+    cusFeature,
+    requiredBalance: requiredBalance ?? 1
+  });
   let result = {
     allowed,
-    feature_id: params.featureId,
+    feature_id: cusFeature?.id ?? params.featureId,
     customer_id: isEntity ? customer.customer_id : customer.id,
     required_balance: requiredBalance,
     ...cusFeature

package/dist/libraries/react/{chunk-ABJEE3UK.mjs → chunk-KUFNEIRV.mjs}

@@ -893,6 +893,31 @@ var CheckoutParamsSchema = z7.object({
   reward: z7.string().optional()
 });
 
+// src/sdk/features/featureTypes.ts
+import { z as z8 } from "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 = z8.object({
+  id: z8.string(),
+  name: z8.string().nullish(),
+  type: z8.nativeEnum(FeatureType),
+  display: z8.object({
+    singular: z8.string(),
+    plural: z8.string()
+  }).nullish(),
+  credit_schema: z8.array(
+    z8.object({
+      metered_feature_id: z8.string(),
+      credit_cost: z8.number()
+    })
+  ).nullish()
+});
+
 export {
   AutumnError,
   toContainerResult,

package/dist/libraries/react/{chunk-PN6WKUSX.mjs → chunk-MUZHFEMO.mjs}

@@ -2,7 +2,7 @@
 
 import {
   AutumnClient
-} from "./chunk-JNJRQ5DT.mjs";
+} from "./chunk-NBVPBAGX.mjs";
 
 // src/libraries/react/AutumnContext.tsx
 import { createContext, useContext } from "react";

package/dist/libraries/react/{chunk-Y5S2HOFE.mjs → chunk-MYRJW7LW.mjs}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-RFSQBGLO.mjs";
 import {
   useCustomerBase
-} from "./chunk-VELC6P5V.mjs";
+} from "./chunk-54IJL24F.mjs";
 
 // src/libraries/react/BaseAutumnProvider.tsx
 import { useRef } from "react";

package/dist/libraries/react/{chunk-JNJRQ5DT.mjs → chunk-NBVPBAGX.mjs}

@@ -1,14 +1,5 @@
 "use client";
 
-import {
-  AutumnError,
-  toContainerResult
-} from "./chunk-ABJEE3UK.mjs";
-import {
-  createEntityMethod,
-  deleteEntityMethod,
-  getEntityMethod
-} from "./chunk-ZF2HUCN6.mjs";
 import {
   attachMethod,
   cancelMethod,
@@ -32,12 +23,21 @@ import {
 import {
   logFetchError
 } from "./chunk-CIBQ4BJU.mjs";
+import {
+  AutumnError,
+  toContainerResult
+} from "./chunk-KUFNEIRV.mjs";
 import {
   getPricingTableMethod
 } from "./chunk-VTGR7VVK.mjs";
 import {
   createCustomerMethod
 } from "./chunk-WFFVOEUG.mjs";
+import {
+  createEntityMethod,
+  deleteEntityMethod,
+  getEntityMethod
+} from "./chunk-ZF2HUCN6.mjs";
 
 // src/libraries/react/client/ReactAutumnClient.tsx
 var AutumnClient = class {
@@ -113,8 +113,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;