@foldspace-fe/casdoor-next-auth-kit 0.1.19 → 0.1.21

package/dist/react/index.js

@@ -9,12 +9,16 @@ import {
   normalizeBillingPurchaseStatus,
   normalizeBillingRuntimeConfig,
   normalizeCasdoorBuyProductResponse,
+  normalizeCasdoorOrderHistoryItem,
+  normalizeCasdoorPaymentHistoryItem,
   normalizeCasdoorProductId,
+  normalizeCasdoorSubscriptionDetail,
+  normalizeCasdoorSubscriptionHistoryItem,
   resolveBillingItem,
   resolveBillingProductSnapshot,
   resolveBillingPurchasable,
   resolveBillingSubscriptionProduct
-} from "../chunk-46V73LSW.js";
+} from "../chunk-FL6LOXEG.js";
 import {
   buildAuthJumpHref
 } from "../chunk-T2M5MVPE.js";
@@ -129,6 +133,66 @@ function extractCasdoorResponseData(response) {
   }
   return response;
 }
+function useBillingCasdoorQuery(loader, buildArgs, deps, missingLoaderMessage) {
+  const [data, setData] = useState();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    if (!loader) {
+      setData(void 0);
+      setError(missingLoaderMessage);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await loader(buildArgs());
+      const extracted = extractCasdoorResponseData(response);
+      setData(extracted);
+      setError(null);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setData(void 0);
+      setError(message);
+    } finally {
+      setLoading(false);
+    }
+  }, [buildArgs, loader, missingLoaderMessage]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh, ...deps]);
+  return useMemo(
+    () => ({
+      data,
+      loading,
+      error,
+      refresh
+    }),
+    [data, error, loading, refresh]
+  );
+}
+function pickCurrentCasdoorSubscription(records) {
+  if (!records.length) return void 0;
+  const active = records.find((record) => {
+    const status = (record.state ?? "").toLowerCase();
+    return status.includes("active") || status.includes("trial");
+  });
+  if (active) return active;
+  return [...records].sort((left, right) => {
+    const leftTime = Date.parse(left.endTime ?? left.createdTime ?? "") || 0;
+    const rightTime = Date.parse(right.endTime ?? right.createdTime ?? "") || 0;
+    return rightTime - leftTime;
+  })[0];
+}
+function pickLatestCasdoorOrder(records) {
+  if (!records.length) return void 0;
+  return [...records].sort((left, right) => {
+    const leftTime = Date.parse(left.updatedTime ?? left.createdTime ?? "") || 0;
+    const rightTime = Date.parse(right.updatedTime ?? right.createdTime ?? "") || 0;
+    return rightTime - leftTime;
+  })[0];
+}
 async function runCasdoorProductPurchase(purchaseRequest, apiClient, loaders) {
   const buyProductLoader = loaders?.buyProductLoader ?? apiClient.buyProduct;
   if (!buyProductLoader) {
@@ -296,9 +360,12 @@ function BillingProvider({
     const resolvedLoaders = loaders ?? {};
     const subscriptionLoader = resolvedLoaders.subscriptionLoader ?? apiClient.fetchSubscription;
     const subscriptionHistoryLoader = resolvedLoaders.subscriptionHistoryLoader ?? apiClient.fetchSubscriptionHistory;
+    const subscriptionsLoader = resolvedLoaders.subscriptionsLoader ?? apiClient.fetchSubscriptions;
     const productsLoader = resolvedLoaders.productsLoader ?? apiClient.fetchProducts;
     const orderHistoryLoader = resolvedLoaders.orderHistoryLoader ?? apiClient.fetchOrderHistory;
+    const ordersLoader = resolvedLoaders.ordersLoader ?? apiClient.fetchOrders;
     const paymentHistoryLoader = resolvedLoaders.paymentHistoryLoader ?? apiClient.fetchPaymentHistory;
+    const paymentLoader = resolvedLoaders.paymentLoader ?? apiClient.fetchPayment;
     const purchaseStatusLoader = resolvedLoaders.purchaseStatusLoader ?? apiClient.fetchPurchaseStatus;
     const creditsLoader = resolvedLoaders.creditsLoader ?? apiClient.fetchCredits;
     const entitlementsLoader = resolvedLoaders.entitlementsLoader ?? apiClient.fetchEntitlements;
@@ -313,31 +380,74 @@ function BillingProvider({
         setRuntimeConfig(nextRuntimeConfig);
       }
       const nextCatalogKey = nextRuntimeConfig?.catalogKey ?? nextRuntimeCatalog?.catalogKey ?? catalogKey;
+      const nextSubscriptionsResponsePromise = subscriptionsLoader ? subscriptionsLoader({}).catch(() => void 0) : Promise.resolve(void 0);
+      const nextOrdersResponsePromise = ordersLoader ? ordersLoader({}).catch(() => void 0) : Promise.resolve(void 0);
       const [
         nextSubscription,
         nextSubscriptionHistory,
+        nextSubscriptionsResponse,
         nextProducts,
         nextOrderHistory,
+        nextOrdersResponse,
         nextPaymentHistory,
         nextCredits,
         nextEntitlements
       ] = await Promise.all([
         subscriptionLoader({ catalogKey: nextCatalogKey }),
         subscriptionHistoryLoader({ catalogKey: nextCatalogKey }),
+        nextSubscriptionsResponsePromise,
         productsLoader({ catalogKey: nextCatalogKey }),
         orderHistoryLoader({ catalogKey: nextCatalogKey }),
+        nextOrdersResponsePromise,
         paymentHistoryLoader({ catalogKey: nextCatalogKey }),
         creditsLoader({ catalogKey: nextCatalogKey }),
         entitlementsLoader({ catalogKey: nextCatalogKey })
       ]);
+      const casdoorSubscriptions = extractCasdoorResponseData(nextSubscriptionsResponse) ?? [];
+      const casdoorOrders = extractCasdoorResponseData(nextOrdersResponse) ?? [];
+      const derivedSubscriptionHistory = nextSubscriptionHistory ?? casdoorSubscriptions.map(normalizeCasdoorSubscriptionHistoryItem);
+      const derivedOrderHistory = nextOrderHistory ?? casdoorOrders.map(normalizeCasdoorOrderHistoryItem);
+      let resolvedPaymentHistory = nextPaymentHistory;
+      if ((!resolvedPaymentHistory || resolvedPaymentHistory.length === 0) && casdoorOrders.length && paymentLoader) {
+        const latestCasdoorOrder = pickLatestCasdoorOrder(casdoorOrders);
+        const paymentId = latestCasdoorOrder?.payment ?? latestCasdoorOrder?.transaction;
+        if (paymentId) {
+          const paymentResponse = await paymentLoader({ id: paymentId }).catch(() => void 0);
+          const paymentDetail = extractCasdoorResponseData(paymentResponse);
+          if (paymentDetail?.name) {
+            resolvedPaymentHistory = [
+              normalizeCasdoorPaymentHistoryItem({
+                name: paymentDetail.name,
+                order: paymentDetail.order,
+                outOrderId: paymentDetail.outOrderId,
+                product: paymentDetail.product ?? paymentDetail.productName,
+                productName: paymentDetail.productName,
+                productDisplayName: paymentDetail.productDisplayName,
+                price: paymentDetail.price,
+                currency: paymentDetail.currency,
+                state: paymentDetail.state,
+                transactionId: paymentDetail.transactionId,
+                createdTime: paymentDetail.createdTime,
+                updatedTime: paymentDetail.updatedTime
+              })
+            ];
+          }
+        }
+      }
       const subscriptionWithProduct = nextSubscription ? {
         ...nextSubscription,
         product: resolveBillingSubscriptionProduct(nextSubscription, nextRuntimeConfig ?? runtimeConfig)
-      } : void 0;
+      } : (() => {
+        const derivedSubscription = normalizeCasdoorSubscriptionDetail(pickCurrentCasdoorSubscription(casdoorSubscriptions));
+        return derivedSubscription ? {
+          ...derivedSubscription,
+          product: resolveBillingSubscriptionProduct(derivedSubscription, nextRuntimeConfig ?? runtimeConfig)
+        } : void 0;
+      })();
       const normalizedCredits = deriveBillingCreditsState(nextCredits, nextProducts, nextRuntimeConfig?.conversionRules ?? runtimeConfig?.conversionRules);
       const normalizedEntitlements = nextEntitlements ?? deriveBillingEntitlements(subscriptionWithProduct, nextProducts, normalizedCredits, nextRuntimeConfig ?? runtimeConfig);
-      const latestOrder = getLatestOrder(nextOrderHistory);
-      const latestPayment = getLatestPayment(nextPaymentHistory);
+      const latestOrder = getLatestOrder(derivedOrderHistory);
+      const latestPayment = getLatestPayment(resolvedPaymentHistory);
       const fetchedPurchaseStatus = await purchaseStatusLoader({
         orderId: latestOrder?.orderId,
         paymentId: latestPayment?.paymentId,
@@ -349,10 +459,10 @@ function BillingProvider({
         latestPayment
       );
       setSubscription(subscriptionWithProduct);
-      setSubscriptionHistory(nextSubscriptionHistory);
+      setSubscriptionHistory(derivedSubscriptionHistory);
       setProducts(nextProducts);
-      setOrderHistory(nextOrderHistory);
-      setPaymentHistory(nextPaymentHistory);
+      setOrderHistory(derivedOrderHistory);
+      setPaymentHistory(resolvedPaymentHistory);
       setCredits(normalizedCredits);
       setEntitlements(normalizedEntitlements);
       setPurchaseStatus(normalizedPurchaseStatus);
@@ -755,6 +865,166 @@ function useBillingProductPurchaseOptions(productId, preferredProviderName) {
     [detailState.error, detailState.loading, detailState.product, detailState.refresh, providerName]
   );
 }
+function useBillingPricing(pricingId) {
+  const core = useRequiredCoreContext();
+  const loader = core.loaders?.pricingLoader ?? core.apiClient.fetchPricing;
+  return useBillingCasdoorQuery(
+    loader,
+    useCallback(() => ({ id: pricingId }), [pricingId]),
+    [pricingId, loader],
+    "Missing billing pricing loader."
+  );
+}
+function useBillingPlan(planId, includeOption = false) {
+  const core = useRequiredCoreContext();
+  const loader = core.loaders?.planLoader ?? core.apiClient.fetchPlan;
+  return useBillingCasdoorQuery(
+    loader,
+    useCallback(() => ({ id: planId, includeOption }), [includeOption, planId]),
+    [includeOption, loader, planId],
+    "Missing billing plan loader."
+  );
+}
+function useBillingOrder(orderId) {
+  const core = useRequiredCoreContext();
+  const loader = core.loaders?.orderLoader ?? core.apiClient.fetchOrder;
+  return useBillingCasdoorQuery(
+    loader,
+    useCallback(() => ({ id: orderId }), [orderId]),
+    [loader, orderId],
+    "Missing billing order loader."
+  );
+}
+function useBillingSubscriptionRecord(subscriptionId) {
+  const core = useRequiredCoreContext();
+  const loader = core.loaders?.subscriptionRecordLoader ?? core.apiClient.fetchSubscriptionRecord;
+  return useBillingCasdoorQuery(
+    loader,
+    useCallback(() => ({ id: subscriptionId }), [subscriptionId]),
+    [loader, subscriptionId],
+    "Missing billing subscription loader."
+  );
+}
+function useBillingOrders(options = {}) {
+  const core = useRequiredCoreContext();
+  const loader = core.loaders?.ordersLoader ?? core.apiClient.fetchOrders;
+  const owner = options.owner;
+  const user = options.user;
+  const product = options.product;
+  return useBillingCasdoorQuery(
+    loader,
+    useCallback(() => ({ owner, user, product }), [owner, product, user]),
+    [loader, owner, product, user],
+    "Missing billing orders loader."
+  );
+}
+function useBillingSubscriptions(options = {}) {
+  const core = useRequiredCoreContext();
+  const loader = core.loaders?.subscriptionsLoader ?? core.apiClient.fetchSubscriptions;
+  const owner = options.owner;
+  const user = options.user;
+  return useBillingCasdoorQuery(
+    loader,
+    useCallback(() => ({ owner, user }), [owner, user]),
+    [loader, owner, user],
+    "Missing billing subscriptions loader."
+  );
+}
+function useBillingPricingPlans(pricingId, includeOption = false, preferredPlanName) {
+  const pricingState = useBillingPricing(pricingId);
+  const core = useRequiredCoreContext();
+  const [selectedPlanName, setSelectedPlanName] = useState(preferredPlanName);
+  const planLoader = core.loaders?.planLoader ?? core.apiClient.fetchPlan;
+  const [plans, setPlans] = useState([]);
+  const [planLoading, setPlanLoading] = useState(false);
+  const [planError, setPlanError] = useState(null);
+  useEffect(() => {
+    if (preferredPlanName) {
+      setSelectedPlanName(preferredPlanName);
+    }
+  }, [preferredPlanName]);
+  useEffect(() => {
+    const nextPlanName = selectedPlanName ?? pricingState.data?.plans?.[0];
+    if (!nextPlanName || selectedPlanName && pricingState.data?.plans && !pricingState.data.plans.includes(selectedPlanName)) {
+      setSelectedPlanName(pricingState.data?.plans?.[0]);
+      return;
+    }
+    if (!selectedPlanName && nextPlanName) {
+      setSelectedPlanName(nextPlanName);
+    }
+  }, [pricingState.data?.plans, selectedPlanName]);
+  const refreshPlans = useCallback(async () => {
+    if (!planLoader) {
+      setPlans([]);
+      setPlanError("Missing billing plan loader.");
+      setPlanLoading(false);
+      return;
+    }
+    const planNames = pricingState.data?.plans ?? [];
+    if (!planNames.length) {
+      setPlans([]);
+      setPlanError(null);
+      setPlanLoading(false);
+      return;
+    }
+    setPlanLoading(true);
+    setPlanError(null);
+    try {
+      const results = await Promise.all(
+        planNames.map(async (planName) => {
+          const response = await planLoader({ id: planName, includeOption });
+          return extractCasdoorResponseData(response);
+        })
+      );
+      setPlans(results.filter((plan) => Boolean(plan)));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setPlans([]);
+      setPlanError(message);
+    } finally {
+      setPlanLoading(false);
+    }
+  }, [includeOption, planLoader, pricingState.data?.plans]);
+  useEffect(() => {
+    void refreshPlans();
+  }, [refreshPlans]);
+  const selectedPlan = useMemo(
+    () => plans.find((plan) => plan.name === selectedPlanName) ?? (plans.length === 1 ? plans[0] : void 0),
+    [plans, selectedPlanName]
+  );
+  return useMemo(
+    () => ({
+      pricing: pricingState.data,
+      plans,
+      selectedPlanName,
+      selectedPlan,
+      setSelectedPlanName,
+      loading: pricingState.loading || planLoading,
+      error: pricingState.error ?? planError,
+      refresh: async () => {
+        await pricingState.refresh();
+        await refreshPlans();
+      }
+    }),
+    [planError, planLoading, plans, pricingState, refreshPlans, selectedPlan, selectedPlanName]
+  );
+}
+function useBillingSubscriptionPurchaseOptions(pricingId, includeOption = false, preferredPlanName) {
+  const pricingPlans = useBillingPricingPlans(pricingId, includeOption, preferredPlanName);
+  return useMemo(
+    () => ({
+      pricing: pricingPlans.pricing,
+      plans: pricingPlans.plans,
+      selectedPlanName: pricingPlans.selectedPlanName,
+      selectedPlan: pricingPlans.selectedPlan,
+      setSelectedPlanName: pricingPlans.setSelectedPlanName,
+      loading: pricingPlans.loading,
+      error: pricingPlans.error,
+      refresh: pricingPlans.refresh
+    }),
+    [pricingPlans]
+  );
+}
 function useBillingProducts() {
   const core = useRequiredCoreContext();
   const productContext = useOptionalContext(BillingProductContext);
@@ -1020,9 +1290,14 @@ export {
   useBillingCredits,
   useBillingEntitlements,
   useBillingItem,
+  useBillingOrder,
   useBillingOrderHistory,
+  useBillingOrders,
   useBillingPaymentHistory,
   useBillingPipeline,
+  useBillingPlan,
+  useBillingPricing,
+  useBillingPricingPlans,
   useBillingProduct,
   useBillingProductDetail,
   useBillingProductPurchaseOptions,
@@ -1033,6 +1308,9 @@ export {
   useBillingSubscription,
   useBillingSubscriptionHistory,
   useBillingSubscriptionProduct,
+  useBillingSubscriptionPurchaseOptions,
+  useBillingSubscriptionRecord,
+  useBillingSubscriptions,
   useCancelSubscription,
   useManageSubscription,
   usePurchaseProduct,