@frontegg/redux-store 5.61.0 → 6.0.1-alpha.2

package/subscriptions/Billing/Invoices/saga.d.ts

@@ -1,13 +1,13 @@
-import { ISubscriptionInvoiceResponse } from '@frontegg/rest-api';
-export declare function subscriptionInvoicesSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
-export declare function loadInvoices(): Generator<import("redux-saga/effects").PutEffect<{
-    payload: boolean;
-    type: string;
-}> | import("redux-saga/effects").CallEffect<ISubscriptionInvoiceResponse[]> | import("redux-saga/effects").PutEffect<{
-    payload: Partial<import("./interfaces").InvoicesState>;
-    type: string;
-}> | import("redux-saga/effects").PutEffect<{
-    payload: string | null;
-    type: string;
-}>, void, ISubscriptionInvoiceResponse[]>;
-export declare function subscriptionInvoicesSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+import { ISubscriptionInvoiceResponse } from '@frontegg/rest-api';
+export declare function subscriptionInvoicesSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export declare function loadInvoices(): Generator<import("redux-saga/effects").PutEffect<{
+    payload: boolean;
+    type: string;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: string | null;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<ISubscriptionInvoiceResponse[]> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("./interfaces").InvoicesState>;
+    type: string;
+}>, void, ISubscriptionInvoiceResponse[]>;
+export declare function subscriptionInvoicesSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;

package/subscriptions/Billing/Invoices/saga.js

@@ -0,0 +1,75 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { call, delay, put, takeEvery } from 'redux-saga/effects';
+import { invoicesActions } from './index';
+import { api } from '@frontegg/rest-api';
+import { invoicesMock } from '../../dummy';
+export function* subscriptionInvoicesSagas() {
+  yield takeEvery(invoicesActions.loadInvoices, loadInvoices);
+  yield takeEvery(invoicesActions.downloadInvoice, downloadInvoice);
+}
+export function* loadInvoices() {
+  yield put(invoicesActions.setLoading(true));
+
+  try {
+    const responseInvoices = yield call(api.subscriptions.getSubscriptionInvoices);
+    const invoices = responseInvoices.map(invoice => ({
+      id: invoice.id,
+      externalId: invoice.externalId,
+      subscriptionId: invoice.subscriptionId,
+      paymentDate: new Date(Date.parse(invoice.paymentDate)),
+      totalAmount: +((invoice.totalAmount || 0) / 100).toFixed(2),
+      currency: invoice.currency || 'usd',
+      paid: invoice.paid || false,
+      receiptNumber: invoice.receiptNumber
+    }));
+    yield put(invoicesActions.setState({
+      loading: false,
+      fetching: false,
+      invoices
+    }));
+  } catch (e) {
+    yield put(invoicesActions.setError(e.message));
+  }
+}
+
+function* downloadInvoice({
+  payload
+}) {
+  yield put(invoicesActions.setInvoiceDownloadState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    yield call(api.subscriptions.getSubscriptionInvoicePdf, payload.invoiceId, payload.filename);
+    yield put(invoicesActions.setInvoiceDownloadState({
+      loading: false,
+      error: null
+    }));
+  } catch (e) {
+    yield put(invoicesActions.setInvoiceDownloadState({
+      loading: false,
+      error: e.message || null
+    }));
+  }
+}
+
+function* loadInvoicesMock() {
+  yield put(invoicesActions.setLoading(true));
+  yield delay(500);
+  const selectPlanTitle = 'Premium';
+  yield put(invoicesActions.setState({
+    loading: false,
+    fetching: false,
+    invoices: invoicesMock.map(invoice => _extends({}, invoice, {
+      selectedPlan: selectPlanTitle,
+      paymentDate: new Date(Date.parse(invoice.paymentDate)),
+      totalAmount: +((invoice.totalAmount || 0) / 100).toFixed(2)
+    }))
+  }));
+  yield put(invoicesActions.setLoading(false));
+}
+
+export function* subscriptionInvoicesSagasMock() {
+  yield takeEvery(invoicesActions.loadInvoices, loadInvoicesMock);
+}

package/subscriptions/Billing/PaymentMethod/index.d.ts

@@ -1,20 +1,20 @@
-import { PaymentMethodState } from './interfaces';
-import { ISubscriptionUpdatePaymentMethodBillingDetails } from '@frontegg/rest-api';
-import { WithCallback } from '../../../interfaces';
-export declare const initialPaymentMethodState: PaymentMethodState;
-declare const reducer: import("redux").Reducer<PaymentMethodState, import("redux").AnyAction>;
-declare const actions: {
-    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<PaymentMethodState>], Partial<PaymentMethodState>, string, never, never>;
-    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    loadPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    submitPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    submitPaymentMethodError: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>;
-    submitPaymentMethodSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    updatePaymentMethodBillingDetails: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
-        id: string;
-    }, boolean>], WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
-        id: string;
-    }, boolean>, string, never, never>;
-};
-export { reducer as subscriptionsPaymentMethodReducer, actions as subscriptionsPaymentMethodActions };
+import { PaymentMethodState } from './interfaces';
+import { ISubscriptionUpdatePaymentMethodBillingDetails } from '@frontegg/rest-api';
+import { WithCallback } from '../../../interfaces';
+export declare const initialPaymentMethodState: PaymentMethodState;
+declare const reducer: import("redux").Reducer<PaymentMethodState, import("redux").AnyAction>;
+declare const actions: {
+    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<PaymentMethodState>], Partial<PaymentMethodState>, string, never, never>;
+    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
+    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
+    loadPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    submitPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    submitPaymentMethodError: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>;
+    submitPaymentMethodSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    updatePaymentMethodBillingDetails: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
+        id: string;
+    }, boolean>], WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
+        id: string;
+    }, boolean>, string, never, never>;
+};
+export { reducer as subscriptionsPaymentMethodReducer, actions as subscriptionsPaymentMethodActions };

package/subscriptions/Billing/PaymentMethod/index.js

@@ -0,0 +1,40 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { createModuleCaseReducers } from '../../utils';
+import { subscriptionsStoreName } from '../../../constants';
+import { createAction, createSlice } from '@reduxjs/toolkit';
+export const initialPaymentMethodState = {
+  loading: false,
+  error: null,
+  fetching: true
+};
+
+const reducers = _extends({}, createModuleCaseReducers(), {
+  setState: {
+    prepare: payload => ({
+      payload
+    }),
+    reducer: (state, action) => _extends({}, state, action.payload)
+  }
+});
+
+const {
+  reducer,
+  actions: paymentActions,
+  name
+} = createSlice({
+  name: `${subscriptionsStoreName}/billing/payment`,
+  initialState: initialPaymentMethodState,
+  reducers
+});
+
+const actions = _extends({
+  loadPaymentMethod: createAction(`${name}/loadPaymentMethod`),
+  submitPaymentMethod: createAction(`${name}/submitPaymentMethod`),
+  submitPaymentMethodError: createAction(`${name}/submitPaymentMethodError`),
+  submitPaymentMethodSuccess: createAction(`${name}/submitPaymentMethodSuccess`),
+  updatePaymentMethodBillingDetails: createAction(`${name}/updateBillingDetails`, payload => ({
+    payload
+  }))
+}, paymentActions);
+
+export { reducer as subscriptionsPaymentMethodReducer, actions as subscriptionsPaymentMethodActions };

package/subscriptions/Billing/PaymentMethod/interfaces.d.ts

@@ -1,46 +1,46 @@
-import { WithCallback } from '../../../interfaces';
-import { ISubscriptionUpdatePaymentMethodBillingDetails } from '@frontegg/rest-api';
-export declare type PaymentMethod = {
-    id: string;
-    type: 'card';
-    externalId?: string;
-    isDefault?: boolean;
-    last4?: string;
-    expMonth?: number;
-    expYear?: number;
-    brand?: string;
-    billingDetails?: BillingDetailsResponse;
-};
-export interface PaymentMethodState {
-    loading: boolean;
-    error: string | null;
-    fetching: boolean;
-    paymentMethod?: PaymentMethod;
-}
-export interface PaymentMethodActions {
-    loadPaymentMethod: () => void;
-    updatePaymentMethodBillingDetails: (payload: WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
-        id: string;
-    }>) => void;
-    setError: (error: string | null) => void;
-    submitPaymentMethod: () => void;
-    submitPaymentMethodError: (error: string) => void;
-    submitPaymentMethodSuccess: () => void;
-}
-export interface BillingDetailsResponse {
-    name?: string;
-    email?: string;
-    address?: AddressResponse;
-}
-export interface AddressResponse {
-    addressLine1?: string;
-    addressLine2?: string;
-    city?: string;
-    state?: string;
-    postalCode?: string;
-    country?: string;
-}
-export declare enum PaymentMethodType {
-    UNKNWON = "unknown",
-    CARD = "card"
-}
+import { WithCallback } from '../../../interfaces';
+import { ISubscriptionUpdatePaymentMethodBillingDetails } from '@frontegg/rest-api';
+export declare type PaymentMethod = {
+    id: string;
+    type: 'card';
+    externalId?: string;
+    isDefault?: boolean;
+    last4?: string;
+    expMonth?: number;
+    expYear?: number;
+    brand?: string;
+    billingDetails?: BillingDetailsResponse;
+};
+export interface PaymentMethodState {
+    loading: boolean;
+    error: string | null;
+    fetching: boolean;
+    paymentMethod?: PaymentMethod;
+}
+export interface PaymentMethodActions {
+    loadPaymentMethod: () => void;
+    updatePaymentMethodBillingDetails: (payload: WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
+        id: string;
+    }>) => void;
+    setError: (error: string | null) => void;
+    submitPaymentMethod: () => void;
+    submitPaymentMethodError: (error: string) => void;
+    submitPaymentMethodSuccess: () => void;
+}
+export interface BillingDetailsResponse {
+    name?: string;
+    email?: string;
+    address?: AddressResponse;
+}
+export interface AddressResponse {
+    addressLine1?: string;
+    addressLine2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+}
+export declare enum PaymentMethodType {
+    UNKNWON = "unknown",
+    CARD = "card"
+}

package/subscriptions/Billing/PaymentMethod/interfaces.js

@@ -0,0 +1,6 @@
+export let PaymentMethodType;
+
+(function (PaymentMethodType) {
+  PaymentMethodType["UNKNWON"] = "unknown";
+  PaymentMethodType["CARD"] = "card";
+})(PaymentMethodType || (PaymentMethodType = {}));

package/subscriptions/Billing/PaymentMethod/saga.d.ts

@@ -1,13 +1,13 @@
-import { ISubscriptionPaymentMethodCardResponse } from '@frontegg/rest-api';
-export declare function subscriptionsPaymentMethodSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
-export declare function loadPaymentMethod(): Generator<import("redux-saga/effects").PutEffect<{
-    payload: boolean;
-    type: string;
-}> | import("redux-saga/effects").CallEffect<import("@frontegg/rest-api").ISubscriptionPaymentMethodResponse[]> | import("redux-saga/effects").PutEffect<{
-    payload: Partial<import("./interfaces").PaymentMethodState>;
-    type: string;
-}> | import("redux-saga/effects").PutEffect<{
-    payload: string | null;
-    type: string;
-}>, void, ISubscriptionPaymentMethodCardResponse[]>;
-export declare function subscriptionsPaymentMethodSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+import { ISubscriptionPaymentMethodCardResponse } from '@frontegg/rest-api';
+export declare function subscriptionsPaymentMethodSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export declare function loadPaymentMethod(): Generator<import("redux-saga/effects").PutEffect<{
+    payload: boolean;
+    type: string;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: string | null;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<import("@frontegg/rest-api").ISubscriptionPaymentMethodResponse[]> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("./interfaces").PaymentMethodState>;
+    type: string;
+}>, void, ISubscriptionPaymentMethodCardResponse[]>;
+export declare function subscriptionsPaymentMethodSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;

package/subscriptions/Billing/PaymentMethod/saga.js

@@ -0,0 +1,81 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { call, put, takeEvery, delay } from 'redux-saga/effects';
+import { subscriptionsPaymentMethodActions } from './index';
+import { api } from '@frontegg/rest-api';
+import { paymentMethodsMock } from '../../dummy';
+export function* subscriptionsPaymentMethodSagas() {
+  yield takeEvery(subscriptionsPaymentMethodActions.loadPaymentMethod, loadPaymentMethod);
+  yield takeEvery(subscriptionsPaymentMethodActions.submitPaymentMethod, submitPaymentMethod);
+  yield takeEvery(subscriptionsPaymentMethodActions.submitPaymentMethodError, submitPaymentMethodError);
+  yield takeEvery(subscriptionsPaymentMethodActions.submitPaymentMethodSuccess, submitPaymentMethodSuccess);
+  yield takeEvery(subscriptionsPaymentMethodActions.updatePaymentMethodBillingDetails, updateBillingDetails);
+}
+export function* loadPaymentMethod() {
+  yield put(subscriptionsPaymentMethodActions.setLoading(true));
+
+  try {
+    const paymentMethods = yield call(api.subscriptions.getPaymentMethods);
+    const paymentMethod = paymentMethods[0];
+    yield put(subscriptionsPaymentMethodActions.setState({
+      paymentMethod,
+      loading: false,
+      fetching: false
+    }));
+  } catch (e) {
+    yield put(subscriptionsPaymentMethodActions.setError(e.message));
+  }
+}
+
+function* updateBillingDetails({
+  payload
+}) {
+  yield put(subscriptionsPaymentMethodActions.setLoading(true));
+  const {
+    id,
+    email,
+    address,
+    callback
+  } = payload;
+
+  try {
+    yield call(api.subscriptions.updatePaymentMethodBillingDetails, id, _extends({
+      email
+    }, address));
+    yield call(loadPaymentMethod);
+    callback == null ? void 0 : callback(true);
+  } catch (e) {
+    yield put(subscriptionsPaymentMethodActions.setError(e.message));
+    callback == null ? void 0 : callback(false);
+  }
+
+  yield put(subscriptionsPaymentMethodActions.setLoading(false));
+}
+
+function* submitPaymentMethod() {
+  yield put(subscriptionsPaymentMethodActions.setLoading(true));
+}
+
+function* submitPaymentMethodError({
+  payload: error
+}) {
+  yield put(subscriptionsPaymentMethodActions.setError(error));
+}
+
+function* submitPaymentMethodSuccess() {
+  yield put(subscriptionsPaymentMethodActions.loadPaymentMethod());
+}
+
+function* loadPaymentMethodMock() {
+  yield put(subscriptionsPaymentMethodActions.setLoading(true));
+  yield delay(500);
+  const paymentMethod = paymentMethodsMock[0];
+  yield put(subscriptionsPaymentMethodActions.setState({
+    paymentMethod,
+    loading: false,
+    fetching: false
+  }));
+}
+
+export function* subscriptionsPaymentMethodSagasMock() {
+  yield takeEvery(subscriptionsPaymentMethodActions.loadPaymentMethod, loadPaymentMethodMock);
+}

package/subscriptions/Billing/Subscription/index.d.ts

@@ -1,16 +1,16 @@
-import { SubscriptionState } from './interfaces';
-export declare const initialSubscriptionState: SubscriptionState;
-declare const reducer: import("redux").Reducer<SubscriptionState, import("redux").AnyAction>;
-declare const actions: {
-    setCancellationLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setCancellationError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setRenewalLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setRenewalError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    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<SubscriptionState>], Partial<SubscriptionState>, string, never, never>;
-    load: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    cancelSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    renewSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-};
-export { reducer as subscriptionReducer, actions as subscriptionActions };
+import { SubscriptionState } from './interfaces';
+export declare const initialSubscriptionState: SubscriptionState;
+declare const reducer: import("redux").Reducer<SubscriptionState, import("redux").AnyAction>;
+declare const actions: {
+    setCancellationLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
+    setCancellationError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
+    setRenewalLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
+    setRenewalError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
+    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<SubscriptionState>], Partial<SubscriptionState>, string, never, never>;
+    load: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    cancelSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    renewSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+};
+export { reducer as subscriptionReducer, actions as subscriptionActions };

package/subscriptions/Billing/Subscription/index.js

@@ -0,0 +1,42 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { createAction, createSlice } from '@reduxjs/toolkit';
+import { subscriptionsStoreName } from '../../../constants';
+import { createKeyCaseErrorReducer, createKeyCaseLoadingReducer, createModuleCaseReducers } from '../../utils';
+export const initialSubscriptionState = {
+  loading: false,
+  error: null,
+  fetching: true,
+  cancellation: {
+    loading: false,
+    error: null
+  },
+  renewal: {
+    loading: false,
+    error: null
+  }
+};
+
+const reducers = _extends({}, createModuleCaseReducers(), {
+  setCancellationLoading: createKeyCaseLoadingReducer('cancellation'),
+  setCancellationError: createKeyCaseErrorReducer('cancellation'),
+  setRenewalLoading: createKeyCaseLoadingReducer('renewal'),
+  setRenewalError: createKeyCaseErrorReducer('renewal')
+});
+
+const {
+  reducer,
+  actions: overviewActions,
+  name
+} = createSlice({
+  name: `${subscriptionsStoreName}/billing/subscription`,
+  initialState: initialSubscriptionState,
+  reducers
+});
+
+const actions = _extends({
+  load: createAction(`${name}/loadSubscription`),
+  cancelSubscription: createAction(`${name}/cancelSubscription`),
+  renewSubscription: createAction(`${name}/renewSubscription`)
+}, overviewActions);
+
+export { reducer as subscriptionReducer, actions as subscriptionActions };

package/subscriptions/Billing/Subscription/interfaces.d.ts

@@ -1,18 +1,18 @@
-import { ISubscriptionResponse } from '@frontegg/rest-api';
-export interface SubscriptionState {
-    loading: boolean;
-    error: string | null;
-    fetching: boolean;
-    subscription?: ISubscriptionResponse;
-    cancellation: {
-        loading: boolean;
-        error: string | null;
-    };
-    renewal: {
-        loading: boolean;
-        error: string | null;
-    };
-}
-export interface SubscriptionActions {
-    load: () => void;
-}
+import { ISubscriptionResponse } from '@frontegg/rest-api';
+export interface SubscriptionState {
+    loading: boolean;
+    error: string | null;
+    fetching: boolean;
+    subscription?: ISubscriptionResponse;
+    cancellation: {
+        loading: boolean;
+        error: string | null;
+    };
+    renewal: {
+        loading: boolean;
+        error: string | null;
+    };
+}
+export interface SubscriptionActions {
+    load: () => void;
+}

package/subscriptions/Billing/Subscription/interfaces.js

@@ -0,0 +1 @@
+export {};

package/subscriptions/Billing/Subscription/saga.d.ts

@@ -1,13 +1,13 @@
-import { SubscriptionState } from './interfaces';
-export declare function subscriptionSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
-export declare function loadSubscription(): Generator<import("redux-saga/effects").PutEffect<{
-    payload: boolean;
-    type: string;
-}> | import("redux-saga/effects").CallEffect<import("@frontegg/rest-api").ISubscriptionResponse[]> | import("redux-saga/effects").PutEffect<{
-    payload: Partial<SubscriptionState>;
-    type: string;
-}> | import("redux-saga/effects").PutEffect<{
-    payload: string | null;
-    type: string;
-}>, void, [any]>;
-export declare function subscriptionSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+import { SubscriptionState } from './interfaces';
+export declare function subscriptionSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export declare function loadSubscription(): Generator<import("redux-saga/effects").PutEffect<{
+    payload: boolean;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<import("@frontegg/rest-api").ISubscriptionResponse[]> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<SubscriptionState>;
+    type: string;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: string | null;
+    type: string;
+}>, void, [any]>;
+export declare function subscriptionSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;

package/subscriptions/Billing/Subscription/saga.js

@@ -0,0 +1,117 @@
+import { call, delay, put, select, takeEvery } from 'redux-saga/effects';
+import { subscriptionActions } from './index';
+import { api, ISubscriptionCancellationPolicy, ISubscriptionStatus } from '@frontegg/rest-api';
+import { subscriptionResponseMock } from '../../dummy';
+import { loadSummaries } from '../Information/saga';
+export function* subscriptionSagas() {
+  yield takeEvery(subscriptionActions.load, loadSubscriptionTenant);
+  yield takeEvery(subscriptionActions.cancelSubscription, cancelSubscription);
+  yield takeEvery(subscriptionActions.renewSubscription, renewSubscription);
+}
+
+function* loadSubscriptionTenant() {
+  const tenantId = yield select(state => {
+    var _state$auth, _state$auth$user;
+
+    return (_state$auth = state.auth) == null ? void 0 : (_state$auth$user = _state$auth.user) == null ? void 0 : _state$auth$user.tenantId;
+  });
+  yield loadSummaries(tenantId);
+}
+
+export function* loadSubscription() {
+  yield put(subscriptionActions.setLoading(true));
+
+  try {
+    const [subscription] = yield call(api.subscriptions.getManagedSubscriptions);
+    yield put(subscriptionActions.setState({
+      subscription,
+      fetching: false,
+      loading: false,
+      error: null
+    }));
+  } catch (e) {
+    yield put(subscriptionActions.setError(e));
+  }
+}
+
+function* cancelSubscription() {
+  const {
+    subscription
+  } = yield select(state => state.subscriptions.billing.subscription);
+
+  if (!subscription) {
+    yield put(subscriptionActions.setCancellationError('Subscription not found.'));
+    return;
+  }
+
+  if (subscription != null && subscription.externallyManaged) {
+    yield put(subscriptionActions.setCancellationError('Billing is externally managed.'));
+    return;
+  }
+
+  const {
+    id: subscriptionId,
+    cancellation,
+    status
+  } = subscription || {};
+  const isCancellable = !cancellation && status === ISubscriptionStatus.ACTIVE;
+
+  if (isCancellable) {
+    try {
+      yield put(subscriptionActions.setCancellationLoading(true));
+      yield call(api.subscriptions.cancelManagedSubscription, subscriptionId);
+      yield loadSubscription();
+      yield put(subscriptionActions.setCancellationLoading(false));
+    } catch (e) {
+      yield put(subscriptionActions.setCancellationError(e.message));
+    }
+  }
+}
+
+function* renewSubscription() {
+  const {
+    subscription
+  } = yield select(state => state.subscriptions.billing.subscription);
+
+  if (!subscription) {
+    yield put(subscriptionActions.setCancellationError('Subscription not found.'));
+    return;
+  }
+
+  if (subscription != null && subscription.externallyManaged) {
+    yield put(subscriptionActions.setCancellationError('Billing is externally managed'));
+    return;
+  }
+
+  const {
+    id: subscriptionId,
+    cancellation
+  } = subscription || {};
+  const renewable = (cancellation == null ? void 0 : cancellation.policy) === ISubscriptionCancellationPolicy.AT_PERIOD_END;
+
+  if (renewable) {
+    try {
+      yield put(subscriptionActions.setRenewalLoading(true));
+      yield call(api.subscriptions.renewManagedSubscription, subscriptionId);
+      yield loadSubscription();
+      yield put(subscriptionActions.setRenewalLoading(false));
+    } catch (e) {
+      yield put(subscriptionActions.setCancellationError(e.message));
+    }
+  }
+}
+
+function* loadMock() {
+  yield put(subscriptionActions.setLoading(true));
+  yield delay(500);
+  yield put(subscriptionActions.setState({
+    subscription: subscriptionResponseMock,
+    fetching: false,
+    loading: false,
+    error: null
+  }));
+}
+
+export function* subscriptionSagasMock() {
+  yield takeEvery(subscriptionActions.load, loadMock);
+}