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

package/toolkit/index.js

@@ -1,128 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { authActions } from '../auth';
-import { configureStore, getDefaultMiddleware, combineReducers, createSlice } from '@reduxjs/toolkit';
-import { createSagaMiddleware } from './redux-saga-tools';
-import { all, call } from 'redux-saga/effects';
-import { ContextHolder } from '@frontegg/rest-api';
-import authStore from '../auth';
-import auditsStore from '../audits';
-import * as oldAuditsStore from '../audits/backward-compatibility';
-import connectivityStore from '../connectivity';
-import subscriptionsStore from '../subscriptions';
-import vendorStore from '../vendor';
-export * from './redux';
-export * from './redux-saga-tools';
-export { bindActionCreators } from '@reduxjs/toolkit';
-const initialState = {
-  context: undefined,
-  urlStrategy: 'path',
-  previewMode: false,
-  appName: 'default'
-};
-const {
-  reducer: rootReducer
-} = createSlice({
-  name: 'root',
-  initialState,
-  reducers: {
-    setContext: {
-      prepare: context => ({
-        payload: context
-      }),
-      reducer: (state, {
-        payload
-      }) => {
-        ContextHolder.setContext(payload);
-        return _extends({}, state, {
-          context: payload
-        });
-      }
-    }
-  }
-});
-export const createFronteggStore = (rootInitialState, storeHolder, previewMode = false, authInitialState, overrideInitialState, builderMode = false, urlStrategy = 'path') => {
-  const isSSR = typeof window === 'undefined';
-  let holder = storeHolder;
-  if (isSSR && storeHolder == null) {
-    throw Error('createFronteggStore(initState, storeHolder) failed, storeHolder must not be null in Server-Side rendering');
-  }
-  if (!holder) {
-    holder = window;
-  }
-  if (!holder.store) {
-    var _overrideInitialState, _authInitialState$rou, _overrideInitialState2, _overrideInitialState3, _overrideInitialState4, _overrideInitialState5, _overrideInitialState6, _overrideInitialState7, _overrideInitialState8, _overrideInitialState9;
-    if (!previewMode && !builderMode) {
-      ContextHolder.setContext(rootInitialState.context);
-    }
-    const sagaMiddleware = createSagaMiddleware();
-    const middleware = [...getDefaultMiddleware({
-      thunk: false,
-      immutableCheck: false,
-      serializableCheck: false
-    }), sagaMiddleware];
-    holder.store = configureStore({
-      middleware,
-      preloadedState: {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        root: _extends({}, rootInitialState, {
-          previewMode,
-          urlStrategy: urlStrategy
-        }),
-        [authStore.storeName]: _extends({}, authStore.initialState, authInitialState, (_overrideInitialState = overrideInitialState == null ? void 0 : overrideInitialState.auth) != null ? _overrideInitialState : {}, {
-          routes: _extends({}, authStore.initialState.routes, (_authInitialState$rou = authInitialState == null ? void 0 : authInitialState.routes) != null ? _authInitialState$rou : {}, (_overrideInitialState2 = overrideInitialState == null ? void 0 : (_overrideInitialState3 = overrideInitialState.auth) == null ? void 0 : _overrideInitialState3.routes) != null ? _overrideInitialState2 : {})
-        }),
-        [auditsStore.storeName]: _extends({}, auditsStore.initialState, (_overrideInitialState4 = overrideInitialState == null ? void 0 : overrideInitialState.auditLogs) != null ? _overrideInitialState4 : {}, {
-          auditLogsState: _extends({}, auditsStore.initialState.auditLogsState, (_overrideInitialState5 = overrideInitialState == null ? void 0 : (_overrideInitialState6 = overrideInitialState.auditLogs) == null ? void 0 : _overrideInitialState6.auditLogsState) != null ? _overrideInitialState5 : {}),
-          auditsMetadataState: _extends({}, auditsStore.initialState.auditsMetadataState, (_overrideInitialState7 = overrideInitialState == null ? void 0 : (_overrideInitialState8 = overrideInitialState.auditLogs) == null ? void 0 : _overrideInitialState8.auditsMetadataState) != null ? _overrideInitialState7 : {})
-        }),
-        [oldAuditsStore.storeName]: _extends({}, oldAuditsStore.initialState, (_overrideInitialState9 = overrideInitialState == null ? void 0 : overrideInitialState.audits) != null ? _overrideInitialState9 : {}),
-        [connectivityStore.storeName]: connectivityStore.initialState,
-        [subscriptionsStore.storeName]: subscriptionsStore.initialState,
-        [vendorStore.storeName]: vendorStore.initialState
-      },
-      reducer: combineReducers({
-        root: rootReducer,
-        [authStore.storeName]: authStore.reducer,
-        [auditsStore.storeName]: auditsStore.reducer,
-        [oldAuditsStore.storeName]: oldAuditsStore.reducer,
-        [connectivityStore.storeName]: connectivityStore.reducer,
-        [subscriptionsStore.storeName]: subscriptionsStore.reducer,
-        [vendorStore.storeName]: vendorStore.reducer
-      })
-    });
-    const rootSaga = function* () {
-      yield all([call(authStore.sagas), call(auditsStore.sagas), call(oldAuditsStore.sagas), call(connectivityStore.sagas), call(subscriptionsStore.sagas), call(vendorStore.sagas)]);
-    };
-    const rootMockSaga = function* () {
-      yield all([call(authStore.mockSagas), call(auditsStore.mockSagas), call(subscriptionsStore.mockSagas)]);
-    };
-    if (previewMode) {
-      holder.store.destroy = sagaMiddleware.run(rootMockSaga).cancel;
-      holder.store.dispatch(authActions.requestAuthorize(true));
-    } else {
-      holder.store.destroy = sagaMiddleware.run(rootSaga).cancel;
-    }
-
-    /**
-     * Using redux store subscribe causes unpredictable callback calls: https://redux.js.org/api/store#subscribelistener
-     *
-     * This function aim to prevent unnecessary update by calling the callback with the updated frontegg state only on state reference change.
-     * This function protect from redux unnecessary updates by reference comparison
-     * Developed for vanilla js SDK
-     *
-     * @param callback called with the updated frontegg state for every store refresh
-     * @returns redux unsubscribe function
-     */
-    holder.store.subscribeStateChanged = callback => {
-      let lastStoreState = holder.store.getState();
-      return holder.store.subscribe(() => {
-        const updatedState = holder.store.getState();
-        if (lastStoreState != updatedState) {
-          lastStoreState = updatedState;
-          callback(updatedState);
-        }
-      });
-    };
-  }
-  return holder.store;
-};
+export { default as FronteggNativeModule } from './FronteggNativeModule';
+export * from './store';
+export { snapshot, subscribe } from 'valtio/vanilla';

package/toolkit/proxy.d.ts

@@ -0,0 +1 @@
+export declare const createProxy: <T extends {}>(initialState: T, overrideState?: Partial<T> | undefined) => T;

package/toolkit/proxy.js

@@ -0,0 +1,9 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { proxy } from 'valtio/vanilla';
+import deepMerge from 'deepmerge';
+export const createProxy = (initialState, overrideState) => {
+  const deepMergedState = deepMerge(initialState, _extends({}, overrideState));
+  return proxy(_extends({
+    __isProxy: true
+  }, deepMergedState));
+};

package/toolkit/store.d.ts

@@ -0,0 +1,59 @@
+import { ContextOptions } from '@frontegg/rest-api';
+import { DeepPartial, FronteggActions, FronteggStateActions, FronteggStore, PartialFronteggState, RootState } from '../interfaces';
+import { AuthState } from '../auth';
+export * from '../auth';
+export * from '../interfaces';
+export declare type StoreHolder = {
+    store: FronteggStore;
+    actions: FronteggActions;
+    stateActions: FronteggStateActions;
+};
+export interface FronteggStoreOptions {
+    /**
+     * The context of the store
+     */
+    context: ContextOptions;
+    /**
+     * The name of the store
+     */
+    name?: string;
+    /**
+     * Override the initial state of the frontegg store
+     */
+    initialState?: PartialFronteggState;
+    /**
+     * Set the store holder for SSR
+     * @default window
+     */
+    storeHolder?: any;
+    /**
+     * Weather to use hash or path for the url strategy
+     */
+    urlStrategy?: 'hash' | 'path';
+    /**
+     * Internal Usage
+     * load Store with mock server
+     */
+    previewMode?: boolean;
+    /**
+     * Internal Usage
+     * load Store as builder mode
+     */
+    builderMode?: boolean;
+}
+/**
+ * @deprecated use createStore instead
+ */
+export declare const createFronteggStore: (rootInitialState: RootState, storeHolder?: any, previewMode?: boolean, authInitialState?: DeepPartial<AuthState> | undefined, overrideInitialState?: Partial<{
+    root: DeepPartial<RootState>;
+    auth: DeepPartial<AuthState>;
+    connectivity: Partial<import("..").ConnectivityState>;
+    subscriptions: DeepPartial<import("..").SubscriptionsState>;
+    vendor: DeepPartial<import("..").VendorState>; /**
+     * Internal Usage
+     * load Store as builder mode
+     */
+    auditLogs: DeepPartial<import("..").AuditsState>;
+    audits: Partial<import("../audits-backward-compatibility/interfaces").OldAuditsState>;
+}> | undefined, builderMode?: boolean, urlStrategy?: 'hash' | 'path') => FronteggStore;
+export declare const createStore: (options: FronteggStoreOptions) => FronteggStore;

package/toolkit/store.js

@@ -0,0 +1,198 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { devtools } from 'valtio/vanilla/utils';
+import { createApiClient, ContextHolder, FetchClient } from '@frontegg/rest-api';
+import { deepClone } from '../helpers';
+import { buildAuthActions, createAuthState } from '../auth';
+import { buildConnectivityActions, createConnectivityState } from '../connectivity';
+import { buildSubscriptionsActions, createSubscriptionsState } from '../subscriptions';
+import { buildVendorActions, createVendorState } from '../vendor';
+import { buildAuditsActions, createAuditsState } from '../audits';
+import setValue from 'set-value';
+import { subscribe } from 'valtio/vanilla';
+import { buildOldAuditsActions, createOldAuditsState } from '../audits-backward-compatibility';
+import buildMockActions from '../mocks';
+import { createProxy } from './proxy';
+export * from '../auth';
+export * from '../interfaces';
+/**
+ * @deprecated use createStore instead
+ */
+export const createFronteggStore = (rootInitialState, storeHolder, previewMode = false, authInitialState, overrideInitialState, builderMode = false, urlStrategy = 'path') => {
+  return createStore({
+    name: rootInitialState.appName,
+    context: rootInitialState.context,
+    storeHolder,
+    previewMode,
+    builderMode,
+    urlStrategy,
+    initialState: {
+      root: _extends({}, rootInitialState),
+      auth: _extends({}, overrideInitialState == null ? void 0 : overrideInitialState.auth, authInitialState),
+      connectivity: _extends({}, overrideInitialState == null ? void 0 : overrideInitialState.connectivity),
+      subscriptions: _extends({}, overrideInitialState == null ? void 0 : overrideInitialState.subscriptions),
+      vendor: _extends({}, overrideInitialState == null ? void 0 : overrideInitialState.vendor),
+      auditLogs: _extends({}, overrideInitialState == null ? void 0 : overrideInitialState.auditLogs),
+      audits: _extends({}, overrideInitialState == null ? void 0 : overrideInitialState.audits)
+    }
+  });
+};
+export const createStore = options => {
+  var _options$initialState, _options$initialState2, _options$initialState3, _options$initialState4, _options$initialState5, _options$initialState6, _options$initialState7;
+  const {
+    storeHolder
+  } = options;
+  const isSSR = typeof window === 'undefined';
+  let holder = storeHolder;
+  if (isSSR && storeHolder == null) {
+    throw Error('createFronteggStore(initState, storeHolder) failed, storeHolder must not be null in Server-Side rendering');
+  }
+  if (!holder) {
+    holder = window;
+  }
+  if (holder.store) {
+    return holder.store;
+  }
+  const appName = options.name || 'default';
+  const {
+    context,
+    previewMode = false,
+    builderMode = false,
+    urlStrategy = 'path'
+  } = options;
+  const contextHolder = ContextHolder.for(appName);
+  if (!previewMode && !builderMode) {
+    contextHolder.setContext(context);
+  }
+  if (context.requestCredentials === undefined) {
+    context.requestCredentials = 'include';
+  }
+  const authState = createAuthState((_options$initialState = options.initialState) == null ? void 0 : _options$initialState.auth);
+  const connectivityState = createConnectivityState((_options$initialState2 = options.initialState) == null ? void 0 : _options$initialState2.connectivity);
+  const subscriptionsState = createSubscriptionsState((_options$initialState3 = options.initialState) == null ? void 0 : _options$initialState3.subscriptions);
+  const vendorState = createVendorState((_options$initialState4 = options.initialState) == null ? void 0 : _options$initialState4.vendor);
+  const auditsState = createAuditsState((_options$initialState5 = options.initialState) == null ? void 0 : _options$initialState5.auditLogs);
+  const oldAuditsState = createOldAuditsState((_options$initialState6 = options.initialState) == null ? void 0 : _options$initialState6.audits);
+  const overrideAuthState = (_options$initialState7 = options.initialState) == null ? void 0 : _options$initialState7.auth;
+  if (overrideAuthState) {
+    Object.keys(overrideAuthState).forEach(key => {
+      setValue(authState, key, overrideAuthState[key], {
+        merge: true
+      });
+    });
+  }
+  const snapshotAuthState = deepClone(authState);
+  const store = createProxy({
+    root: {
+      appName,
+      context,
+      urlStrategy,
+      previewMode
+    },
+    auth: authState,
+    connectivity: connectivityState,
+    subscriptions: subscriptionsState,
+    vendor: vendorState,
+    auditLogs: auditsState,
+    audits: oldAuditsState
+  });
+  if (typeof window !== 'undefined' && (localStorage['DEBUG_FRONTEGG_STORE'] === 'true' || process.env.NODE_ENV === 'development')) {
+    devtools(store, {
+      name: `${appName} Store`,
+      enabled: true
+    });
+  }
+  const stateActions = {};
+  const actions = {};
+  contextHolder.setContext(options.context);
+  contextHolder.setAppName(appName);
+  const restApiInstance = createApiClient(appName);
+  const fetchInstance = new FetchClient(appName);
+  const api = _extends({}, restApiInstance, {
+    fetch: fetchInstance
+  });
+  if (options.previewMode || options.builderMode) {
+    const {
+      authActions,
+      authStateActions,
+      connectivityActions,
+      subscriptionsActions,
+      subscriptionsStateActions,
+      vendorActions,
+      auditsActions
+    } = buildMockActions(store, api, actions);
+    stateActions.auth = authStateActions;
+    stateActions.connectivity = connectivityActions;
+    stateActions.subscriptions = subscriptionsStateActions;
+    stateActions.vendor = vendorActions;
+    stateActions.auditLogs = auditsActions;
+    stateActions.audits = {};
+    Object.assign(actions, _extends({}, authActions, connectivityActions, subscriptionsActions, vendorActions, auditsActions));
+    const fronteggStore = {
+      dispatch: action => {
+        setTimeout(() => {
+          const [namespace, ...rest] = action.type.split('/');
+          const actionName = rest.join('/');
+          if (namespace === 'auth' && typeof authActions[actionName] === 'function') {
+            authActions[actionName](action.payload);
+          } else if (namespace === 'connectivity' && typeof connectivityActions[actionName] === 'function') {
+            connectivityActions[actionName](action.payload);
+          } else if (namespace === 'subscriptions' && typeof subscriptionsActions[actionName] === 'function') {
+            subscriptionsActions[actionName](action.payload);
+          } else if (namespace === 'vendor' && typeof vendorActions[actionName] === 'function') {
+            vendorActions[actionName](action.payload);
+          }
+        });
+      },
+      getState: () => store,
+      subscribe: callback => subscribe(store, callback),
+      store,
+      actions,
+      stateActions
+    };
+    if (options.previewMode) {
+      fronteggStore.dispatch({
+        type: 'auth/requestAuthorize',
+        payload: true
+      });
+    }
+    if (holder) {
+      holder.store = fronteggStore;
+    }
+    return fronteggStore;
+  } else {
+    const [authActions, authStateActions] = buildAuthActions(store, api, actions, snapshotAuthState);
+    const connectivityActions = buildConnectivityActions(store, api, actions);
+    const [subscriptionsActions, subscriptionsStateActions] = buildSubscriptionsActions(store, api, actions);
+    const vendorActions = buildVendorActions(store, api, actions);
+    const auditsActions = buildAuditsActions(store, api, actions);
+    const oldAuditsActions = buildOldAuditsActions(store, api, actions);
+    stateActions.auth = authStateActions;
+    stateActions.connectivity = connectivityActions;
+    stateActions.subscriptions = subscriptionsStateActions;
+    stateActions.vendor = vendorActions;
+    stateActions.auditLogs = auditsActions;
+    stateActions.audits = oldAuditsActions;
+    Object.assign(actions, _extends({}, authActions, connectivityActions, subscriptionsActions, vendorActions, auditsActions));
+    return {
+      dispatch: action => {
+        const [namespace, ...rest] = action.type.split('/');
+        const actionName = rest.join('/');
+        if (namespace === 'auth' && typeof authActions[actionName] === 'function') {
+          authActions[actionName](action.payload);
+        } else if (namespace === 'connectivity' && typeof connectivityActions[actionName] === 'function') {
+          connectivityActions[actionName](action.payload);
+        } else if (namespace === 'subscriptions' && typeof subscriptionsActions[actionName] === 'function') {
+          subscriptionsActions[actionName](action.payload);
+        } else if (namespace === 'vendor' && typeof vendorActions[actionName] === 'function') {
+          vendorActions[actionName](action.payload);
+        }
+      },
+      getState: () => store,
+      subscribe: callback => subscribe(store, callback),
+      store,
+      actions,
+      stateActions
+    };
+  }
+};

package/vendor/actions.d.ts

@@ -0,0 +1,12 @@
+import { FronteggState, RestApi, SharedActions } from '../interfaces';
+import { VendorState } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setVendorState: (state: Partial<VendorState>) => void;
+    resetVendorState: () => void;
+    loadVendorPublicInfo: () => Promise<void>;
+    /**
+     * @deprecated use loadVendorPublicInfo instead
+     */
+    loadVendorPublicConfiguration: () => Promise<void>;
+};
+export default _default;

package/vendor/actions.js

@@ -0,0 +1,38 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { initialState } from './state';
+import { deepClone } from '../helpers';
+export default ((store, api, sharedActions) => {
+  const setVendorState = state => {
+    Object.assign(store.vendor, state);
+  };
+  const resetVendorState = () => {
+    store.vendor = deepClone(initialState);
+  };
+  const loadVendorPublicInfo = async () => {
+    setVendorState({
+      loading: true
+    });
+    try {
+      var _vendorInfo$whiteLabe;
+      const vendorInfo = await api.vendor.getVendorPublicInfo();
+      vendorInfo.whiteLabelMode = (_vendorInfo$whiteLabe = vendorInfo.whiteLabelMode) != null ? _vendorInfo$whiteLabe : false;
+      setVendorState(_extends({}, vendorInfo, {
+        loading: false
+      }));
+    } catch (e) {
+      setVendorState({
+        loading: false
+      });
+      console.error('failed to getVendorPublicInfo - ', e);
+    }
+  };
+  return {
+    setVendorState,
+    resetVendorState,
+    loadVendorPublicInfo,
+    /**
+     * @deprecated use loadVendorPublicInfo instead
+     */
+    loadVendorPublicConfiguration: loadVendorPublicInfo
+  };
+});

package/vendor/index.d.ts

@@ -1,17 +1,4 @@
-import { reducer, actions, initialState } from './reducer';
-import { sagas } from './saga';
-import { vendorStoreName as storeName } from '../constants';
-export * from './interfaces';
-export type { VendorActions } from './VendorState';
-export { sagas as vendorSagas, reducer as vendorReducers, actions as vendorActions, initialState as vendorInitialState, storeName as vendorStoreName, };
-declare const _default: {
-    sagas: typeof sagas;
-    storeName: string;
-    initialState: import("./interfaces").VendorState;
-    reducer: import("redux").Reducer<import("./interfaces").VendorState, import("redux").AnyAction>;
-    actions: {
-        loadVendorPublicInfo: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        setVendorState: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<import("./interfaces").VendorState>, string>;
-    };
-};
-export default _default;
+import createVendorState from './state';
+import buildVendorActions from './actions';
+export { createVendorState, buildVendorActions };
+export declare type VendorActions = ReturnType<typeof buildVendorActions>;

package/vendor/index.js

@@ -1,16 +1,3 @@
-import { reducer, actions, initialState } from './reducer';
-import { sagas } from './saga';
-import { vendorStoreName as storeName } from '../constants';
-
-// export types
-export * from './interfaces';
-export { sagas as vendorSagas, reducer as vendorReducers, actions as vendorActions, initialState as vendorInitialState, storeName as vendorStoreName };
-
-// export store
-export default {
-  sagas,
-  storeName,
-  initialState,
-  reducer,
-  actions
-};
+import createVendorState from './state';
+import buildVendorActions from './actions';
+export { createVendorState, buildVendorActions };

package/vendor/interfaces.d.ts

@@ -1,4 +1,7 @@
 export interface VendorState {
-    whiteLabelMode?: boolean;
     loading: boolean;
+    name?: string;
+    logo?: string;
+    icon?: string;
+    whiteLabelMode?: boolean;
 }

package/vendor/state.d.ts

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

package/vendor/state.js

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

package/audits/AuditLogsState/saga.d.ts

@@ -1,2 +0,0 @@
-export declare function auditLogsSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
-export declare function auditLogsSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;