@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/subscriptions/Billing/interfaces.d.ts

@@ -1,19 +1,13 @@
-import { BillingInformationActions, BillingInformationState } from './Information/interfaces';
-import { PaymentMethodActions, PaymentMethodState } from './PaymentMethod/interfaces';
-import { InvoicesActions, InvoicesState } from './Invoices/interfaces';
-import { SubscriptionActions, SubscriptionState } from './Subscription/interfaces';
+import { BillingInformationState } from './Information/interfaces';
+import { PaymentMethodState } from './PaymentMethod/interfaces';
+import { InvoicesState } from './Invoices/interfaces';
+import { SubscriptionState } from './Subscription/interfaces';
 export interface BillingState {
     information: BillingInformationState;
     paymentMethod: PaymentMethodState;
     invoices: InvoicesState;
     subscription: SubscriptionState;
 }
-export declare type BillingActions = {
-    information: BillingInformationActions;
-    paymentMethod: PaymentMethodActions;
-    invoices: InvoicesActions;
-    subscription: SubscriptionActions;
-};
 export * from './Information/interfaces';
 export * from './PaymentMethod/interfaces';
 export * from './Invoices/interfaces';

package/subscriptions/Billing/interfaces.js

@@ -1,5 +1,3 @@
-//TODO: rename information to billing
-
 export * from './Information/interfaces';
 export * from './PaymentMethod/interfaces';
 export * from './Invoices/interfaces';

package/subscriptions/Checkout/actions.d.ts

@@ -0,0 +1,12 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { CheckoutState, ConfirmCheckoutActionPayload } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setCheckoutState: (state: Partial<CheckoutState>) => void;
+    resetCheckoutState: () => void;
+    loadCheckout: () => void;
+    resetCheckout: () => void;
+    submitCheckout: () => void;
+    confirmCheckout: (payload: ConfirmCheckoutActionPayload) => Promise<void>;
+    errorCheckout: (payload: string) => void;
+};
+export default _default;

package/subscriptions/Checkout/actions.js

@@ -0,0 +1,100 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { deepClone, errorHandler } from '../../helpers';
+import { initialState } from './state';
+import { ISubscriptionStatus } from '@frontegg/rest-api';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setCheckoutState = state => {
+    Object.assign(store.subscriptions.checkout, state);
+  };
+  const resetCheckoutState = () => {
+    store.subscriptions.checkout = deepClone(initialState);
+  };
+  const loadCheckout = () => {
+    setCheckoutState({
+      fetching: false,
+      loading: false,
+      error: null,
+      confirmed: false
+    });
+  };
+  const resetCheckout = () => {
+    setCheckoutState({
+      loading: false,
+      error: null,
+      confirmed: false
+    });
+  };
+  const submitCheckout = () => {
+    setCheckoutState({
+      loading: true,
+      error: null
+    });
+  };
+  const confirmCheckout = async payload => {
+    const {
+      paymentMethodId,
+      planId
+    } = payload;
+    const subscription = store.subscriptions.billing.subscription.subscription;
+    const summary = store.subscriptions.billing.information.summary;
+    const isTrialing = (subscription == null ? void 0 : subscription.status) === ISubscriptionStatus.TRIALING;
+    const hasPaymentMethod = !!(summary != null && summary.paymentMethodId);
+    if (!subscription) {
+      setCheckoutState({
+        loading: false,
+        error: 'Subscription not found'
+      });
+      return;
+    }
+    setCheckoutState({
+      loading: true,
+      error: null
+    });
+    if (isTrialing && hasPaymentMethod) {
+      setCheckoutState({
+        loading: false,
+        error: null,
+        confirmed: true
+      });
+      actions.setBillingSubscriptionState({
+        subscription: _extends({}, subscription, {
+          status: ISubscriptionStatus.ACTIVE
+        })
+      });
+      return;
+    }
+    try {
+      await api.subscriptions.updateManagedSubscription(subscription.id, {
+        paymentMethodId,
+        planId
+      });
+      await Promise.all([actions.loadBillingInformation(), actions.loadPaymentMethod(), actions.loadInvoices()]);
+      setCheckoutState({
+        loading: false,
+        error: null,
+        confirmed: true
+      });
+    } catch (e) {
+      setCheckoutState({
+        loading: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  const errorCheckout = payload => {
+    setCheckoutState({
+      loading: false,
+      error: payload
+    });
+  };
+  return {
+    setCheckoutState,
+    resetCheckoutState,
+    loadCheckout,
+    resetCheckout,
+    submitCheckout,
+    confirmCheckout,
+    errorCheckout
+  };
+});

package/subscriptions/Checkout/index.d.ts

@@ -1,14 +1,3 @@
-import { CheckoutState, ConfirmCheckoutActionPayload } from './interfaces';
-export declare const checkoutInitialState: CheckoutState;
-declare const reducer: import("redux").Reducer<CheckoutState, import("redux").AnyAction>;
-declare const actions: {
-    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<CheckoutState>], Partial<CheckoutState>, string, never, never>;
-    loadCheckout: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    resetCheckout: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    submitCheckout: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    confirmCheckout: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[ConfirmCheckoutActionPayload], ConfirmCheckoutActionPayload, string, never, never>;
-    errorCheckout: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string], string, string, never, never>;
-};
-export { reducer as checkoutReducer, actions as checkoutActions };
+import createCheckoutState from './state';
+import buildCheckoutActions from './actions';
+export { createCheckoutState, buildCheckoutActions };

package/subscriptions/Checkout/index.js

@@ -1,32 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createAction, createSlice } from '@reduxjs/toolkit';
-import { createModuleCaseReducers } from '../utils';
-import { subscriptionsStoreName } from '../../constants';
-export const checkoutInitialState = {
-  fetching: true,
-  loading: false,
-  error: null,
-  confirmed: false
-};
-const reducers = _extends({}, createModuleCaseReducers());
-const {
-  actions: checkoutActions,
-  reducer,
-  name
-} = createSlice({
-  name: `${subscriptionsStoreName}/checkout`,
-  initialState: checkoutInitialState,
-  reducers
-});
-const actions = _extends({
-  loadCheckout: createAction(`${name}/loadCheckout`),
-  resetCheckout: createAction(`${name}/resetCheckout`),
-  submitCheckout: createAction(`${name}/submitCheckout`),
-  confirmCheckout: createAction(`${name}/confirmCheckout`, payload => ({
-    payload
-  })),
-  errorCheckout: createAction(`${name}/errorCheckout`, payload => ({
-    payload
-  }))
-}, checkoutActions);
-export { reducer as checkoutReducer, actions as checkoutActions };
+import createCheckoutState from './state';
+import buildCheckoutActions from './actions';
+export { createCheckoutState, buildCheckoutActions };

package/subscriptions/Checkout/interfaces.d.ts

@@ -4,13 +4,6 @@ export interface CheckoutState {
     error: string | null;
     confirmed: boolean;
 }
-export interface CheckoutActions {
-    loadCheckout: () => void;
-    resetCheckout: () => void;
-    submitCheckout: () => void;
-    confirmCheckout: (payload: ConfirmCheckoutActionPayload) => void;
-    errorCheckout: (error: string) => void;
-}
 export interface ConfirmCheckoutActionPayload {
     paymentMethodId: string;
     planId: string;

package/subscriptions/Checkout/state.d.ts

@@ -0,0 +1,4 @@
+import { CheckoutState } from './interfaces';
+export declare const initialState: CheckoutState;
+declare const _default: (overrideState?: Partial<CheckoutState> | undefined) => CheckoutState;
+export default _default;

package/subscriptions/Checkout/state.js

@@ -0,0 +1,8 @@
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  fetching: true,
+  loading: false,
+  error: null,
+  confirmed: false
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/subscriptions/Config/actions.d.ts

@@ -0,0 +1,8 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { PaymentProviderConfigState } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setPaymentConfigState: (state: Partial<PaymentProviderConfigState>) => void;
+    resetPaymentConfigState: () => void;
+    loadPaymentConfiguration: () => Promise<void>;
+};
+export default _default;

package/subscriptions/Config/actions.js

@@ -0,0 +1,62 @@
+import { deepClone, errorHandler } from '../../helpers';
+import { initialState } from './state';
+import { ProviderType } from '@frontegg/rest-api';
+import { PaymentProvider } from '../interfaces';
+export default ((store, api, sharedActions) => {
+  const setPaymentConfigState = state => {
+    Object.assign(store.subscriptions.config, state);
+  };
+  const resetPaymentConfigState = () => {
+    store.subscriptions.config = deepClone(initialState);
+  };
+  const setPaymentConfigError = error => {
+    Object.assign(store.subscriptions.config, {
+      error,
+      loading: false,
+      fetching: false
+    });
+  };
+  const loadStripePaymentConfiguration = async () => {
+    setPaymentConfigState({
+      loading: true
+    });
+    try {
+      const response = await api.subscriptions.getStripePaymentProviderConfiguration();
+      const config = {
+        paymentProvider: PaymentProvider.STRIPE,
+        apiKey: response.publishableKey
+      };
+      setPaymentConfigState({
+        config
+      });
+      setPaymentConfigState({
+        loading: false,
+        fetching: false
+      });
+    } catch (e) {
+      setPaymentConfigError(errorHandler(e));
+    }
+  };
+  const loadPaymentConfiguration = async () => {
+    setPaymentConfigState({
+      loading: true
+    });
+    try {
+      var _await$api$subscripti;
+      const response = (_await$api$subscripti = await api.subscriptions.getPaymentProviders()) != null ? _await$api$subscripti : [];
+      const stripePaymentProvider = response.find(paymentProvider => paymentProvider.status === '1' && paymentProvider.providerType === ProviderType.Stripe);
+      if (stripePaymentProvider) {
+        await loadStripePaymentConfiguration();
+      } else {
+        setPaymentConfigError(errorHandler('Payment provider not configured'));
+      }
+    } catch (e) {
+      setPaymentConfigError(errorHandler(e));
+    }
+  };
+  return {
+    setPaymentConfigState,
+    resetPaymentConfigState,
+    loadPaymentConfiguration
+  };
+});

package/subscriptions/Config/index.d.ts

@@ -1,10 +1,3 @@
-import { PaymentProviderConfigState } from './interfaces';
-export declare const configInitialState: PaymentProviderConfigState;
-declare const reducer: import("redux").Reducer<PaymentProviderConfigState, import("redux").AnyAction>;
-declare const actions: {
-    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<PaymentProviderConfigState>], Partial<PaymentProviderConfigState>, string, never, never>;
-    loadPaymentConfiguration: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-};
-export { reducer as configReducer, actions as configActions };
+import createConfigState from './state';
+import buildConfigActions from './actions';
+export { createConfigState, buildConfigActions };

package/subscriptions/Config/index.js

@@ -1,24 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createAction, createSlice } from '@reduxjs/toolkit';
-import { subscriptionsStoreName } from '../../constants';
-import { createModuleCaseReducers } from '../utils';
-export const configInitialState = {
-  loading: false,
-  error: null,
-  fetching: true,
-  config: null
-};
-const reducers = _extends({}, createModuleCaseReducers());
-const {
-  actions: configActions,
-  reducer,
-  name
-} = createSlice({
-  name: `${subscriptionsStoreName}/config`,
-  initialState: configInitialState,
-  reducers
-});
-const actions = _extends({
-  loadPaymentConfiguration: createAction(`${name}/loadPaymentConfiguration`)
-}, configActions);
-export { reducer as configReducer, actions as configActions };
+import createConfigState from './state';
+import buildConfigActions from './actions';
+export { createConfigState, buildConfigActions };

package/subscriptions/Config/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { PaymentProvider } from '../general.interfaces';
+import { PaymentProvider } from '../interfaces';
 interface StripePaymentProviderConfig {
     paymentProvider: PaymentProvider.STRIPE;
     apiKey: string;

package/subscriptions/Config/state.d.ts

@@ -0,0 +1,4 @@
+import { PaymentProviderConfigState } from './interfaces';
+export declare const initialState: PaymentProviderConfigState;
+declare const _default: (overrideState?: Partial<PaymentProviderConfigState> | undefined) => PaymentProviderConfigState;
+export default _default;

package/subscriptions/Config/state.js

@@ -0,0 +1,8 @@
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  error: null,
+  fetching: true,
+  config: null
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/subscriptions/Plans/actions.d.ts

@@ -0,0 +1,8 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { PlansState } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setPlansState: (state: Partial<PlansState>) => void;
+    resetPlansState: () => void;
+    loadPlans: () => Promise<void>;
+};
+export default _default;

package/subscriptions/Plans/actions.js

@@ -0,0 +1,49 @@
+import { deepClone, errorHandler } from '../../helpers';
+import { initialState } from './state';
+export default ((store, api, sharedActions) => {
+  const setPlansState = state => {
+    Object.assign(store.subscriptions.plans, state);
+  };
+  const resetPlansState = () => {
+    store.subscriptions.plans = deepClone(initialState);
+  };
+  const setPlansError = error => {
+    setPlansState({
+      loading: false,
+      fetching: false,
+      error
+    });
+  };
+  const loadPlans = async () => {
+    setPlansState({
+      loading: true
+    });
+    try {
+      const products = await api.subscriptions.getSubscriptionPlans();
+      const plans = products.map(item => {
+        var _item$price, _item$price2;
+        return {
+          id: item.id,
+          name: item.name,
+          description: item.description,
+          price: ((_item$price = item.price) == null ? void 0 : _item$price.amount) || 0,
+          currency: ((_item$price2 = item.price) == null ? void 0 : _item$price2.currency) || 'usd',
+          recurringInterval: 'month',
+          slug: item.slug
+        };
+      });
+      setPlansState({
+        fetching: false,
+        loading: false,
+        plans
+      });
+    } catch (e) {
+      setPlansError(errorHandler(e));
+    }
+  };
+  return {
+    setPlansState,
+    resetPlansState,
+    loadPlans
+  };
+});

package/subscriptions/Plans/index.d.ts

@@ -1,10 +1,3 @@
-import { PlansState } from './interfaces';
-export declare const plansInitialState: PlansState;
-declare const reducer: import("redux").Reducer<PlansState, import("redux").AnyAction>;
-declare const actions: {
-    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<PlansState>], Partial<PlansState>, string, never, never>;
-    loadPlans: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-};
-export { actions as plansActions, reducer as plansReducer };
+import createPlansState from './state';
+import buildPlansActions from './actions';
+export { createPlansState, buildPlansActions };

package/subscriptions/Plans/index.js

@@ -1,23 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createAction, createSlice } from '@reduxjs/toolkit';
-import { subscriptionsStoreName } from '../../constants';
-import { createModuleCaseReducers } from '../utils';
-export const plansInitialState = {
-  loading: false,
-  error: null,
-  fetching: true,
-  plans: []
-};
-const {
-  actions: sliceActions,
-  reducer,
-  name
-} = createSlice({
-  name: `${subscriptionsStoreName}/plans`,
-  initialState: plansInitialState,
-  reducers: _extends({}, createModuleCaseReducers())
-});
-const actions = _extends({
-  loadPlans: createAction(`${name}/loadPlans`)
-}, sliceActions);
-export { actions as plansActions, reducer as plansReducer };
+import createPlansState from './state';
+import buildPlansActions from './actions';
+export { createPlansState, buildPlansActions };

package/subscriptions/Plans/interfaces.d.ts

@@ -1,10 +1,7 @@
-import { Plan } from '../general.interfaces';
+import { Plan } from '../interfaces';
 export interface PlansState {
     loading: boolean;
     error: string | null;
     fetching: boolean;
     plans: Plan[];
 }
-export interface PlansActions {
-    loadPlans: () => void;
-}

package/subscriptions/Plans/state.d.ts

@@ -0,0 +1,4 @@
+import { PlansState } from './interfaces';
+export declare const initialState: PlansState;
+declare const _default: (overrideState?: Partial<PlansState> | undefined) => PlansState;
+export default _default;

package/subscriptions/Plans/state.js

@@ -0,0 +1,8 @@
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  error: null,
+  fetching: true,
+  plans: []
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/subscriptions/Stripe/actions.d.ts

@@ -0,0 +1,6 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { PaymentMethodId } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    createCardSetupIntentSecret: (payload: PaymentMethodId) => Promise<void>;
+};
+export default _default;

package/subscriptions/Stripe/actions.js

@@ -0,0 +1,43 @@
+import { initialState } from './state';
+import { deepClone, errorHandler } from '../../helpers';
+export default ((store, api, sharedActions) => {
+  const setStripeState = state => {
+    Object.assign(store.subscriptions.stripe, state);
+  };
+  const resetStripeState = () => {
+    store.subscriptions.stripe = deepClone(initialState);
+  };
+  const setStripeError = error => {
+    Object.assign(store.subscriptions.stripe, {
+      error,
+      loading: false,
+      fetching: false
+    });
+  };
+  const createCardSetupIntentSecret = async payload => {
+    setStripeState({
+      loading: true,
+      error: null,
+      cardSetupIntentSecret: null
+    });
+    try {
+      const request = {};
+      if (payload) {
+        request.paymentMethodId = payload;
+      }
+      const {
+        setupIntentSecret
+      } = await api.subscriptions.createStripePaymentMethodSetupIntentSecret(request);
+      setStripeState({
+        cardSetupIntentSecret: setupIntentSecret,
+        loading: false
+      });
+    } catch (e) {
+      setStripeError(errorHandler(e));
+    }
+  };
+  return {
+    // loadCustomer, // not implemented
+    createCardSetupIntentSecret
+  };
+});

package/subscriptions/Stripe/index.d.ts

@@ -1,11 +1,3 @@
-import { StripeState } from './interfaces';
-export declare const initialSubscriptionStripeState: StripeState;
-declare const reducer: import("redux").Reducer<StripeState, import("redux").AnyAction>;
-declare const actions: {
-    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<StripeState>], Partial<StripeState>, string, never, never>;
-    loadCustomer: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    createCardSetupIntentSecret: import("@reduxjs/toolkit").ActionCreatorWithPayload<string | null, string>;
-};
-export { reducer as stripeReducer, actions as stripeActions };
+import createStripeState from './state';
+import buildStripeActions from './actions';
+export { createStripeState, buildStripeActions };

package/subscriptions/Stripe/index.js

@@ -1,24 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createAction, createSlice } from '@reduxjs/toolkit';
-import { createModuleCaseReducers } from '../utils';
-import { subscriptionsStoreName } from '../../constants';
-export const initialSubscriptionStripeState = {
-  loading: false,
-  error: null,
-  cardSetupIntentSecret: null
-};
-const reducers = _extends({}, createModuleCaseReducers());
-const {
-  reducer,
-  actions: reducerActions,
-  name
-} = createSlice({
-  name: `${subscriptionsStoreName}/stripe`,
-  initialState: initialSubscriptionStripeState,
-  reducers
-});
-const actions = _extends({
-  loadCustomer: createAction(`${name}/loadCustomer`),
-  createCardSetupIntentSecret: createAction(`${name}/createCardSetupIntentSecret`)
-}, reducerActions);
-export { reducer as stripeReducer, actions as stripeActions };
+import createStripeState from './state';
+import buildStripeActions from './actions';
+export { createStripeState, buildStripeActions };

package/subscriptions/Stripe/state.d.ts

@@ -0,0 +1,4 @@
+import { StripeState } from './interfaces';
+export declare const initialState: StripeState;
+declare const _default: (overrideState?: Partial<StripeState> | undefined) => StripeState;
+export default _default;

package/subscriptions/Stripe/state.js

@@ -0,0 +1,7 @@
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  error: null,
+  cardSetupIntentSecret: null
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/subscriptions/VendorPublicConfig/actions.d.ts

@@ -0,0 +1,10 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { VendorPublicConfigurationState } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setVendorPublicConfigState: (state: Partial<VendorPublicConfigurationState>) => void;
+    resetVendorPublicConfigState: () => void;
+    setVendorPublicConfigError: (error: string) => void;
+    setVendorPublicConfigLoading: (loading: boolean) => void;
+    loadVendorPublicConfiguration: () => Promise<void>;
+};
+export default _default;