@looker/api-explorer 0.9.55 → 0.9.57

package/src/state/settings/sagas.spec.ts

@@ -23,99 +23,99 @@
  SOFTWARE.
 
  */
-import ReduxSagaTester from 'redux-saga-tester'
+import ReduxSagaTester from 'redux-saga-tester';
 
-import { getEnvAdaptor, registerTestEnvAdaptor } from '@looker/extension-utils'
-import { StoreConstants } from '@looker/run-it'
-import * as sagas from './sagas'
-import { settingActions, defaultSettings, settingsSlice } from './slice'
+import { getEnvAdaptor, registerTestEnvAdaptor } from '@looker/extension-utils';
+import { StoreConstants } from '@looker/run-it';
+import * as sagas from './sagas';
+import { defaultSettings, settingActions, settingsSlice } from './slice';
 
 describe('Settings Sagas', () => {
-  let sagaTester: ReduxSagaTester<any>
-  registerTestEnvAdaptor()
+  let sagaTester: ReduxSagaTester<any>;
+  registerTestEnvAdaptor();
 
   beforeEach(() => {
-    jest.resetAllMocks()
+    jest.resetAllMocks();
     sagaTester = new ReduxSagaTester({
       initialState: { settings: { sdkLanguage: 'Go' } },
       reducers: {
         settings: settingsSlice.reducer,
       },
-    })
-    localStorage.clear()
-    sagaTester.start(sagas.saga)
-  })
+    });
+    localStorage.clear();
+    sagaTester.start(sagas.saga);
+  });
 
   describe('setSdkLanguageSaga', () => {
-    const setSdkLanguageAction = settingActions.setSdkLanguageAction
+    const setSdkLanguageAction = settingActions.setSdkLanguageAction;
 
     test('persists value sdkLanguage in localstorage', async () => {
-      sagaTester.dispatch(setSdkLanguageAction({ sdkLanguage: 'Kotlin' }))
-      await sagaTester.waitFor('settings/setSdkLanguageAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(1)
+      sagaTester.dispatch(setSdkLanguageAction({ sdkLanguage: 'Kotlin' }));
+      await sagaTester.waitFor('settings/setSdkLanguageAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(1);
       expect(calledActions[0]).toEqual(
         setSdkLanguageAction({
           sdkLanguage: 'Kotlin',
         })
-      )
+      );
       expect(localStorage.setItem).toHaveBeenLastCalledWith(
         StoreConstants.LOCALSTORAGE_SETTINGS_KEY,
         JSON.stringify({ sdkLanguage: 'Kotlin' })
-      )
-    })
-  })
+      );
+    });
+  });
 
   describe('initSaga', () => {
     const {
       initSettingsAction,
       initSettingsSuccessAction,
       initSettingsFailureAction,
-    } = settingActions
+    } = settingActions;
 
     test('sends initSuccess action with defaults on success if no persisted settings are found', async () => {
-      sagaTester.dispatch(initSettingsAction())
-      await sagaTester.waitFor('settings/initSettingsSuccessAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initSettingsAction())
+      sagaTester.dispatch(initSettingsAction());
+      await sagaTester.waitFor('settings/initSettingsSuccessAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(2);
+      expect(calledActions[0]).toEqual(initSettingsAction());
       expect(calledActions[1]).toEqual(
         initSettingsSuccessAction({
           ...defaultSettings,
         })
-      )
-    })
+      );
+    });
 
     test('sends initSettingsSuccessAction with persisted language on success', async () => {
       jest
         .spyOn(getEnvAdaptor(), 'localStorageGetItem')
-        .mockResolvedValueOnce(JSON.stringify({ sdkLanguage: 'Go' }))
+        .mockResolvedValueOnce(JSON.stringify({ sdkLanguage: 'Go' }));
 
-      sagaTester.dispatch(initSettingsAction())
-      await sagaTester.waitFor('settings/initSettingsSuccessAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initSettingsAction())
+      sagaTester.dispatch(initSettingsAction());
+      await sagaTester.waitFor('settings/initSettingsSuccessAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(2);
+      expect(calledActions[0]).toEqual(initSettingsAction());
       expect(calledActions[1]).toEqual(
         initSettingsSuccessAction({
           ...defaultSettings,
           sdkLanguage: 'Go',
         })
-      )
-    })
+      );
+    });
 
     test('sends initSettingsFailureAction on error', async () => {
-      const error = new Error('boom')
+      const error = new Error('boom');
       jest
         .spyOn(getEnvAdaptor(), 'localStorageGetItem')
-        .mockRejectedValueOnce(error)
-
-      sagaTester.dispatch(initSettingsAction())
-      await sagaTester.waitFor('settings/initSettingsFailureAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initSettingsAction())
-      expect(calledActions[1]).toEqual(initSettingsFailureAction(error))
-    })
-  })
-})
+        .mockRejectedValueOnce(error);
+
+      sagaTester.dispatch(initSettingsAction());
+      await sagaTester.waitFor('settings/initSettingsFailureAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(2);
+      expect(calledActions[0]).toEqual(initSettingsAction());
+      expect(calledActions[1]).toEqual(initSettingsFailureAction(error));
+    });
+  });
+});

package/src/state/settings/sagas.ts

@@ -23,38 +23,38 @@
  SOFTWARE.
 
  */
-import { takeEvery, call, put, select } from 'typed-redux-saga'
+import { call, put, select, takeEvery } from 'typed-redux-saga';
 
-import { getEnvAdaptor } from '@looker/extension-utils'
-import { StoreConstants } from '@looker/run-it'
-import type { RootState } from '../store'
-import { settingActions, defaultSettings } from './slice'
+import { getEnvAdaptor } from '@looker/extension-utils';
+import { StoreConstants } from '@looker/run-it';
+import type { RootState } from '../store';
+import { defaultSettings, settingActions } from './slice';
 
 /**
  * Serializes state to local storage
  */
 function* serializeToLocalStorageSaga() {
-  const adaptor = getEnvAdaptor()
+  const adaptor = getEnvAdaptor();
   const settings = yield* select((state: RootState) => ({
     sdkLanguage: state.settings.sdkLanguage,
-  }))
+  }));
   adaptor.localStorageSetItem(
     StoreConstants.LOCALSTORAGE_SETTINGS_KEY,
     JSON.stringify(settings)
-  )
+  );
 }
 
 /**
  * Returns default settings overridden with any persisted state in local storage
  */
 async function deserializeLocalStorage() {
-  const adaptor = getEnvAdaptor()
+  const adaptor = getEnvAdaptor();
   const settings = await adaptor.localStorageGetItem(
     StoreConstants.LOCALSTORAGE_SETTINGS_KEY
-  )
+  );
   return settings
     ? { ...defaultSettings, ...JSON.parse(settings) }
-    : defaultSettings
+    : defaultSettings;
 }
 
 /**
@@ -62,18 +62,18 @@ async function deserializeLocalStorage() {
  */
 function* initSaga() {
   const { initSettingsSuccessAction, initSettingsFailureAction } =
-    settingActions
+    settingActions;
   try {
-    const settings = yield* call(deserializeLocalStorage)
-    yield* put(initSettingsSuccessAction(settings))
+    const settings = yield* call(deserializeLocalStorage);
+    yield* put(initSettingsSuccessAction(settings));
   } catch (error: any) {
-    yield* put(initSettingsFailureAction(error))
+    yield* put(initSettingsFailureAction(error));
   }
 }
 
 export function* saga() {
-  const { initSettingsAction, setSdkLanguageAction } = settingActions
+  const { initSettingsAction, setSdkLanguageAction } = settingActions;
 
-  yield* takeEvery(initSettingsAction, initSaga)
-  yield* takeEvery(setSdkLanguageAction, serializeToLocalStorageSaga)
+  yield* takeEvery(initSettingsAction, initSaga);
+  yield* takeEvery(setSdkLanguageAction, serializeToLocalStorageSaga);
 }

package/src/state/settings/selectors.spec.ts

@@ -23,25 +23,25 @@
  SOFTWARE.
 
  */
-import { createTestStore, preloadedState } from '../../test-utils'
-import { selectSdkLanguage, isInitialized, selectTagFilter } from './selectors'
+import { createTestStore, preloadedState } from '../../test-utils';
+import { isInitialized, selectSdkLanguage, selectTagFilter } from './selectors';
 
-const testStore = createTestStore()
+const testStore = createTestStore();
 
 describe('Settings selectors', () => {
-  const state = testStore.getState()
+  const state = testStore.getState();
 
   test('selectSdkLanguage selects', () => {
     expect(selectSdkLanguage(state)).toEqual(
       preloadedState.settings.sdkLanguage
-    )
-  })
+    );
+  });
 
   test('selectTagFilter selects', () => {
-    expect(selectTagFilter(state)).toEqual(preloadedState.settings.tagFilter)
-  })
+    expect(selectTagFilter(state)).toEqual(preloadedState.settings.tagFilter);
+  });
 
   test('isInitialized selects', () => {
-    expect(isInitialized(state)).toEqual(preloadedState.settings.initialized)
-  })
-})
+    expect(isInitialized(state)).toEqual(preloadedState.settings.initialized);
+  });
+});

package/src/state/settings/selectors.ts

@@ -23,21 +23,21 @@
  SOFTWARE.
 
  */
-import type { RootState } from '../store'
+import type { RootState } from '../store';
 
-const selectSettingsState = (state: RootState) => state.settings
+const selectSettingsState = (state: RootState) => state.settings;
 
 export const selectSdkLanguage = (state: RootState) =>
-  selectSettingsState(state).sdkLanguage
+  selectSettingsState(state).sdkLanguage;
 
 export const selectSearchPattern = (state: RootState) =>
-  selectSettingsState(state).searchPattern
+  selectSettingsState(state).searchPattern;
 
 export const selectSearchCriteria = (state: RootState) =>
-  selectSettingsState(state).searchCriteria
+  selectSettingsState(state).searchCriteria;
 
 export const selectTagFilter = (state: RootState) =>
-  selectSettingsState(state).tagFilter
+  selectSettingsState(state).tagFilter;
 
 export const isInitialized = (state: RootState) =>
-  selectSettingsState(state).initialized
+  selectSettingsState(state).initialized;

package/src/state/settings/slice.ts

@@ -23,24 +23,24 @@
  SOFTWARE.
 
  */
-import { createSlice } from '@reduxjs/toolkit'
-import type { PayloadAction } from '@reduxjs/toolkit'
-import { createSliceHooks } from '@looker/redux'
-import type { SearchCriterionTerm } from '@looker/sdk-codegen'
-import { SearchAll, setToCriteria } from '@looker/sdk-codegen'
+import { createSlice } from '@reduxjs/toolkit';
+import type { PayloadAction } from '@reduxjs/toolkit';
+import { createSliceHooks } from '@looker/redux';
+import type { SearchCriterionTerm } from '@looker/sdk-codegen';
+import { SearchAll, setToCriteria } from '@looker/sdk-codegen';
 
-import { saga } from './sagas'
+import { saga } from './sagas';
 
 export interface UserDefinedSettings {
-  sdkLanguage: string
+  sdkLanguage: string;
 }
 
 export interface SettingState extends UserDefinedSettings {
-  searchPattern: string
-  searchCriteria: SearchCriterionTerm[]
-  tagFilter: string
-  initialized: boolean
-  error?: Error
+  searchPattern: string;
+  searchCriteria: SearchCriterionTerm[];
+  tagFilter: string;
+  initialized: boolean;
+  error?: Error;
 }
 
 export const defaultSettings = {
@@ -48,18 +48,18 @@ export const defaultSettings = {
   searchPattern: '',
   searchCriteria: setToCriteria(SearchAll) as SearchCriterionTerm[],
   tagFilter: 'ALL',
-}
+};
 
 export const defaultSettingsState: SettingState = {
   ...defaultSettings,
   initialized: false,
-}
+};
 
-type SetSearchPatternAction = Pick<SettingState, 'searchPattern'>
-type SetSdkLanguageAction = Pick<SettingState, 'sdkLanguage'>
-type SetTagFilterAction = Pick<SettingState, 'tagFilter'>
+type SetSearchPatternAction = Pick<SettingState, 'searchPattern'>;
+type SetSdkLanguageAction = Pick<SettingState, 'sdkLanguage'>;
+type SetTagFilterAction = Pick<SettingState, 'tagFilter'>;
 
-export type InitSuccessPayload = UserDefinedSettings
+export type InitSuccessPayload = UserDefinedSettings;
 
 export const settingsSlice = createSlice({
   name: 'settings',
@@ -71,30 +71,30 @@ export const settingsSlice = createSlice({
       state,
       action: PayloadAction<InitSuccessPayload>
     ) {
-      state.sdkLanguage = action.payload.sdkLanguage
-      state.initialized = true
+      state.sdkLanguage = action.payload.sdkLanguage;
+      state.initialized = true;
     },
     initSettingsFailureAction(state, action: PayloadAction<Error>) {
-      state.error = action.payload
-      state.initialized = false
+      state.error = action.payload;
+      state.initialized = false;
     },
     setSdkLanguageAction(state, action: PayloadAction<SetSdkLanguageAction>) {
-      state.sdkLanguage = action.payload.sdkLanguage
+      state.sdkLanguage = action.payload.sdkLanguage;
     },
     setSearchPatternAction(
       state,
       action: PayloadAction<SetSearchPatternAction>
     ) {
-      state.searchPattern = action.payload.searchPattern
+      state.searchPattern = action.payload.searchPattern;
     },
     setTagFilterAction(state, action: PayloadAction<SetTagFilterAction>) {
-      state.tagFilter = action.payload.tagFilter
+      state.tagFilter = action.payload.tagFilter;
     },
   },
-})
+});
 
-export const settingActions = settingsSlice.actions
+export const settingActions = settingsSlice.actions;
 export const {
   useActions: useSettingActions,
   useStoreState: useSettingStoreState,
-} = createSliceHooks(settingsSlice, saga)
+} = createSliceHooks(settingsSlice, saga);

package/src/state/specs/index.ts

@@ -23,5 +23,5 @@
  SOFTWARE.
 
  */
-export * from './selectors'
-export * from './slice'
+export * from './selectors';
+export * from './slice';

package/src/state/specs/sagas.spec.ts

@@ -23,113 +23,113 @@
  SOFTWARE.
 
  */
-import ReduxSagaTester from 'redux-saga-tester'
-import { registerTestEnvAdaptor } from '@looker/extension-utils'
-import { initRunItSdk } from '@looker/run-it'
-import cloneDeep from 'lodash/cloneDeep'
-import { ApixAdaptor } from '../../utils'
+import ReduxSagaTester from 'redux-saga-tester';
+import { registerTestEnvAdaptor } from '@looker/extension-utils';
+import { initRunItSdk } from '@looker/run-it';
+import cloneDeep from 'lodash/cloneDeep';
+import { ApixAdaptor } from '../../utils';
 
-import { getLoadedSpecs } from '../../test-data'
-import { specActions, specsSlice } from './slice'
-import * as sagas from './sagas'
+import { getLoadedSpecs } from '../../test-data';
+import { specActions, specsSlice } from './slice';
+import * as sagas from './sagas';
 
 describe('Specs Sagas', () => {
-  let sagaTester: ReduxSagaTester<any>
-  const adaptor = new ApixAdaptor(initRunItSdk(), '')
-  registerTestEnvAdaptor(adaptor)
-  const specState = getLoadedSpecs()
-  const mockError = new Error('boom')
+  let sagaTester: ReduxSagaTester<any>;
+  const adaptor = new ApixAdaptor(initRunItSdk(), '');
+  registerTestEnvAdaptor(adaptor);
+  const specState = getLoadedSpecs();
+  const mockError = new Error('boom');
 
   beforeEach(() => {
-    jest.resetAllMocks()
+    jest.resetAllMocks();
     sagaTester = new ReduxSagaTester({
       initialState: { specs: { specs: specState } },
       reducers: {
         specs: specsSlice.reducer,
       },
-    })
-    sagaTester.start(sagas.saga)
-  })
+    });
+    sagaTester.start(sagas.saga);
+  });
 
   describe('initSaga', () => {
     const { initSpecsAction, initSpecsFailureAction, initSpecsSuccessAction } =
-      specActions
+      specActions;
 
     it('sends initSpecsFailureAction on error', async () => {
-      jest.spyOn(adaptor, 'fetchSpecList').mockRejectedValueOnce(mockError)
+      jest.spyOn(adaptor, 'fetchSpecList').mockRejectedValueOnce(mockError);
 
-      sagaTester.dispatch(initSpecsAction({ specKey: null }))
-      await sagaTester.waitFor('specs/initSpecsFailureAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initSpecsAction({ specKey: null }))
-      expect(calledActions[1]).toEqual(initSpecsFailureAction(mockError))
-    })
+      sagaTester.dispatch(initSpecsAction({ specKey: null }));
+      await sagaTester.waitFor('specs/initSpecsFailureAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(2);
+      expect(calledActions[0]).toEqual(initSpecsAction({ specKey: null }));
+      expect(calledActions[1]).toEqual(initSpecsFailureAction(mockError));
+    });
 
     it('sends initSpecsSuccessAction on success', async () => {
       // fetchSpecList returns the test specs
       jest
         .spyOn(adaptor, 'fetchSpecList')
-        .mockResolvedValueOnce(cloneDeep(specState))
+        .mockResolvedValueOnce(cloneDeep(specState));
 
-      const currentSpec = specState['3.1']
-      jest.spyOn(adaptor, 'fetchSpec').mockResolvedValueOnce(currentSpec!)
+      const currentSpec = specState['3.1'];
+      jest.spyOn(adaptor, 'fetchSpec').mockResolvedValueOnce(currentSpec!);
 
       // expected state is all the specs with the current spec containing the ApiModel
-      const expected = cloneDeep(specState)
-      expected[currentSpec.key] = currentSpec
-
-      sagaTester.dispatch(initSpecsAction({ specKey: null }))
-      await sagaTester.waitFor('specs/initSpecsSuccessAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initSpecsAction({ specKey: null }))
+      const expected = cloneDeep(specState);
+      expected[currentSpec.key] = currentSpec;
+
+      sagaTester.dispatch(initSpecsAction({ specKey: null }));
+      await sagaTester.waitFor('specs/initSpecsSuccessAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(2);
+      expect(calledActions[0]).toEqual(initSpecsAction({ specKey: null }));
       expect(calledActions[1]).toEqual(
         initSpecsSuccessAction({
           specs: expected,
           currentSpecKey: currentSpec.key,
         })
-      )
-    })
-  })
+      );
+    });
+  });
 
   describe('setCurrentSpecSaga', () => {
     const {
       setCurrentSpecAction,
       setCurrentSpecSuccessAction,
       setCurrentSpecFailureAction,
-    } = specActions
-    const spec = specState['4.0']
+    } = specActions;
+    const spec = specState['4.0'];
 
     it('sends setCurrentSpecSuccessAction on success', async () => {
-      jest.spyOn(adaptor, 'fetchSpec').mockResolvedValueOnce(spec)
+      jest.spyOn(adaptor, 'fetchSpec').mockResolvedValueOnce(spec);
 
-      sagaTester.dispatch(setCurrentSpecAction({ currentSpecKey: spec.key }))
-      await sagaTester.waitFor('specs/setCurrentSpecAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(2)
+      sagaTester.dispatch(setCurrentSpecAction({ currentSpecKey: spec.key }));
+      await sagaTester.waitFor('specs/setCurrentSpecAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(2);
       expect(calledActions[0]).toEqual(
         setCurrentSpecAction({ currentSpecKey: spec.key })
-      )
+      );
       expect(calledActions[1]).toEqual(
         setCurrentSpecSuccessAction({
           api: spec.api!,
           currentSpecKey: spec.key,
         })
-      )
-    })
+      );
+    });
 
     it('sends setCurrentSpecFailureAction on failure', async () => {
-      jest.spyOn(adaptor, 'fetchSpec').mockRejectedValueOnce(mockError)
+      jest.spyOn(adaptor, 'fetchSpec').mockRejectedValueOnce(mockError);
 
-      sagaTester.dispatch(setCurrentSpecAction({ currentSpecKey: spec.key }))
-      await sagaTester.waitFor('specs/setCurrentSpecAction')
-      const calledActions = sagaTester.getCalledActions()
-      expect(calledActions).toHaveLength(2)
+      sagaTester.dispatch(setCurrentSpecAction({ currentSpecKey: spec.key }));
+      await sagaTester.waitFor('specs/setCurrentSpecAction');
+      const calledActions = sagaTester.getCalledActions();
+      expect(calledActions).toHaveLength(2);
       expect(calledActions[0]).toEqual(
         setCurrentSpecAction({ currentSpecKey: spec.key })
-      )
-      expect(calledActions[1]).toEqual(setCurrentSpecFailureAction(mockError))
-    })
-  })
-})
+      );
+      expect(calledActions[1]).toEqual(setCurrentSpecFailureAction(mockError));
+    });
+  });
+});