@looker/api-explorer 0.9.22 → 0.9.27

package/src/state/specs/slice.ts

@@ -0,0 +1,109 @@
+/*
+
+ MIT License
+
+ Copyright (c) 2021 Looker Data Sciences, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+ */
+import type { PayloadAction } from '@reduxjs/toolkit'
+import { createSlice } from '@reduxjs/toolkit'
+import type { ApiModel, SpecList } from '@looker/sdk-codegen'
+import { createSliceHooks } from '@looker/redux'
+
+import { saga } from './sagas'
+
+export interface SpecState {
+  specs: SpecList
+  currentSpecKey: string
+  error?: Error
+  working: boolean
+  description?: string
+}
+
+export const defaultSpecsState: SpecState = {
+  specs: {},
+  currentSpecKey: '',
+  working: true,
+  description: undefined,
+}
+
+export interface InitSpecsAction {
+  specKey: string | null
+}
+
+export interface InitSpecsSuccessPayload {
+  specs: SpecList
+  currentSpecKey: string
+}
+
+export interface SetCurrentSpecAction {
+  currentSpecKey: string
+}
+
+interface SetCurrentSpecSuccessAction {
+  api: ApiModel
+  currentSpecKey: string
+}
+
+export const specsSlice = createSlice({
+  name: 'specs',
+  initialState: defaultSpecsState,
+  reducers: {
+    initSpecsAction(state, _action: PayloadAction<InitSpecsAction>) {
+      state.working = true
+      state.description = 'Fetching specifications...'
+    },
+    initSpecsSuccessAction(
+      state,
+      action: PayloadAction<InitSpecsSuccessPayload>
+    ) {
+      state.specs = action.payload.specs
+      state.currentSpecKey = action.payload.currentSpecKey
+      state.working = false
+      state.description = undefined
+    },
+    initSpecsFailureAction(state, action: PayloadAction<Error>) {
+      state.working = false
+      state.error = action.payload
+    },
+    setCurrentSpecAction(state, action: PayloadAction<SetCurrentSpecAction>) {
+      state.working = true
+      state.description = `Fetching API ${action.payload.currentSpecKey} spec`
+    },
+    setCurrentSpecSuccessAction(
+      state,
+      action: PayloadAction<SetCurrentSpecSuccessAction>
+    ) {
+      state.currentSpecKey = action.payload.currentSpecKey
+      state.specs[state.currentSpecKey].api = action.payload.api
+      state.description = undefined
+      state.working = false
+    },
+    setCurrentSpecFailureAction(state, action: PayloadAction<Error>) {
+      state.working = false
+      state.error = action.payload
+    },
+  },
+})
+
+export const specActions = specsSlice.actions
+export const { useActions: useSpecActions, useStoreState: useSpecStoreState } =
+  createSliceHooks(specsSlice, saga)

package/src/state/store.ts

@@ -24,19 +24,82 @@
 
  */
 import { createStore } from '@looker/redux'
+import type { PayloadAction } from '@reduxjs/toolkit'
+import type { Action } from 'redux'
+import map from 'lodash/map'
+import type { SpecList } from '@looker/sdk-codegen'
 
 import type { SettingState } from './settings'
-import { defaultSettingsState, slice } from './settings'
+import { defaultSettingsState, settingsSlice } from './settings'
+import type { LodesState } from './lodes'
+import { lodesSlice, defaultLodesState } from './lodes'
+import type { SpecState, InitSpecsSuccessPayload } from './specs'
+import { defaultSpecsState, specsSlice } from './specs'
+
+const isInitSuccessAction = (
+  action: any
+): action is PayloadAction<InitSpecsSuccessPayload> => !!action.payload?.specs
+
+const actionSanitizer = <A extends Partial<Action>>(
+  action: A,
+  _id: number
+): A => {
+  if (isInitSuccessAction(action)) {
+    action = {
+      ...action,
+      payload: {
+        ...action.payload,
+        specs: sanitizeSpecs(action.payload.specs),
+      },
+    }
+  }
+  return action
+}
+
+const stateSanitizer = <S extends Partial<RootState>>(
+  state: S,
+  _index: number
+): S => {
+  if (state.specs) {
+    return {
+      ...state,
+      specs: {
+        ...state.specs,
+        specs: sanitizeSpecs(state.specs.specs),
+      },
+    }
+  }
+  return state
+}
+
+const sanitizeSpecs = (specList: SpecList) =>
+  map(specList, (spec) => ({
+    ...spec,
+    api: spec.api ? '<api>' : undefined,
+    specContent: spec.specContent ? '<specContent>' : undefined,
+  })) as unknown as SpecList
+
+const devTools =
+  process.env.NODE_ENV !== 'production'
+    ? { actionSanitizer, stateSanitizer }
+    : false
 
 export const store = createStore({
+  devTools,
   preloadedState: {
     settings: defaultSettingsState,
+    lodes: defaultLodesState,
+    specs: defaultSpecsState,
   },
   reducer: {
-    settings: slice.reducer,
+    settings: settingsSlice.reducer,
+    lodes: lodesSlice.reducer,
+    specs: specsSlice.reducer,
   },
 })
 
 export interface RootState {
   settings: SettingState
+  lodes: LodesState
+  specs: SpecState
 }

package/src/{context/lode/LodeContext.ts → test-data/declarations.ts}

@@ -23,18 +23,21 @@
  SOFTWARE.
 
  */
-import { createContext } from 'react'
-import type { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen'
-
-interface LodeContextProps {
-  examples: IExampleMine
-  declarations?: IDeclarationMine
-}
-
-export const defaultLodeContextValue: LodeContextProps = {
-  examples: { commitHash: '', remoteOrigin: '', nuggets: {}, summaries: {} },
+import type { IDeclarationMine } from '@looker/sdk-codegen'
+
+export const declarations: IDeclarationMine = {
+  commitHash: '1e9348b797c2f3760d03c1f94c60f18e534e8298',
+  remoteOrigin: 'https://github.com/looker-open-source/sdk-codegen',
+  types: {
+    FullLode: {
+      line: 40,
+      sourceFile: 'packages/api-explorer/src/utils/lodeUtils.ts',
+    },
+  },
+  methods: {
+    getLoded: {
+      line: 45,
+      sourceFile: 'packages/api-explorer/src/utils/lodeUtils.ts',
+    },
+  },
 }
-
-export const LodeContext = createContext<LodeContextProps>(
-  defaultLodeContextValue
-)

package/src/test-data/index.ts

@@ -23,12 +23,6 @@
  SOFTWARE.
 
  */
-export {
-  api,
-  api40,
-  specs,
-  specState,
-  getLoadedSpecs,
-  getLoadedSpecState,
-} from './specs'
+export * from './specs'
 export { examples } from './examples'
+export * from './declarations'

package/src/test-data/specs.ts

@@ -25,8 +25,8 @@
  */
 import type { SpecList } from '@looker/sdk-codegen'
 import { ApiModel } from '@looker/sdk-codegen'
-
-import { initDefaultSpecState } from '../reducers'
+import type { SpecState } from '../state'
+import { defaultSpecsState } from '../state'
 
 export const specs: SpecList = {
   '3.1': {
@@ -47,8 +47,6 @@ export const specs: SpecList = {
   },
 }
 
-export const specState = initDefaultSpecState(specs, window.location)
-
 export const api = ApiModel.fromJson(specs['3.1'].specContent)
 export const api40 = ApiModel.fromJson(specs['4.0'].specContent)
 
@@ -59,5 +57,7 @@ export const getLoadedSpecs = () => {
   return loadedSpecs
 }
 
-export const getLoadedSpecState = () =>
-  initDefaultSpecState(getLoadedSpecs(), window.location)
+export const specState: SpecState = {
+  ...defaultSpecsState,
+  specs: getLoadedSpecs(),
+}

package/src/test-utils/index.ts

@@ -23,10 +23,6 @@
  SOFTWARE.
 
  */
-export {
-  renderWithLode,
-  renderWithReduxProviderAndLode,
-} from './render_with_lode'
+export * from './lodes'
 export * from './router'
 export * from './redux'
-export { registerTestEnvAdaptor } from './envAdaptor'

package/src/{reducers/spec/reducer.spec.ts → test-utils/lodes.tsx}

@@ -23,22 +23,19 @@
  SOFTWARE.
 
  */
-import { ApiModel } from '@looker/sdk-codegen'
-
-import { specs } from '../../test-data'
-import type { SelectSpecAction } from '.'
-import { specReducer, initDefaultSpecState, Actions } from '.'
-
-describe('Spec Reducer', () => {
-  test('it selects a spec', () => {
-    const action: SelectSpecAction = {
-      type: Actions.SELECT_SPEC,
-      payload: '4.0',
-    }
-
-    const state = specReducer(initDefaultSpecState(specs, location), action)
-    expect(state.spec.api).toBeInstanceOf(ApiModel)
-    expect(state.spec.key).toEqual('4.0')
-    expect(state.spec.status).toEqual(specs['4.0'].status)
-  })
-})
+import type { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen'
+import type { ReactElement } from 'react'
+import type { RenderOptions } from '@testing-library/react'
+import { renderWithTheme } from '@looker/components-test-utils'
+
+import { createTestStore, withReduxProvider } from './redux'
+
+export const renderWithLode = (
+  consumers: ReactElement<any>,
+  examples: IExampleMine,
+  declarations?: IDeclarationMine,
+  options?: Omit<RenderOptions, 'queries'>
+) => {
+  const store = createTestStore({ lodes: { examples, declarations } })
+  return renderWithTheme(withReduxProvider(consumers, store), options)
+}

package/src/test-utils/redux.tsx

@@ -23,6 +23,7 @@
  SOFTWARE.
 
  */
+
 import type { ReactElement } from 'react'
 import React from 'react'
 import { Provider } from 'react-redux'
@@ -30,18 +31,26 @@ import type { Store } from 'redux'
 import { renderWithTheme } from '@looker/components-test-utils'
 import type { RenderOptions } from '@testing-library/react'
 import { createStore } from '@looker/redux'
+import { BrowserAdaptor, registerEnvAdaptor } from '@looker/extension-utils'
+import { initRunItSdk } from '@looker/run-it'
 
-import type { RootState, SettingState } from '../state'
-import { defaultSettingsState, store as defaultStore } from '../state'
-import { slice as settingsSlice } from '../state/settings'
-import { registerEnvAdaptor, StandaloneEnvAdaptor } from '../utils'
+import type { LodesState, RootState, SettingState, SpecState } from '../state'
+import {
+  settingsSlice,
+  defaultLodesState,
+  defaultSettingsState,
+  lodesSlice,
+  defaultSpecsState,
+  specsSlice,
+} from '../state'
+import { specState } from '../test-data'
 import { renderWithRouter } from './router'
 
 export const withReduxProvider = (
   consumers: ReactElement<any>,
-  store: Store<RootState> = defaultStore
+  store: Store<RootState> = createTestStore()
 ) => {
-  registerEnvAdaptor(new StandaloneEnvAdaptor())
+  registerEnvAdaptor(new BrowserAdaptor(initRunItSdk()))
   return <Provider store={store}>{consumers}</Provider>
 }
 
@@ -59,8 +68,10 @@ export const renderWithRouterAndReduxProvider = (
 ) =>
   renderWithRouter(withReduxProvider(consumers, store), initialEntries, options)
 
-const preloadedState: RootState = {
+export const preloadedState: RootState = {
   settings: defaultSettingsState,
+  lodes: defaultLodesState,
+  specs: defaultSpecsState,
 }
 
 type DeepPartial<T> = {
@@ -74,6 +85,18 @@ export const createTestStore = (overrides?: DeepPartial<RootState>) =>
         ...preloadedState.settings,
         ...overrides?.settings,
       } as SettingState,
+      lodes: {
+        ...defaultLodesState,
+        ...overrides?.lodes,
+      } as LodesState,
+      specs: {
+        ...specState,
+        ...overrides?.specs,
+      } as SpecState,
+    },
+    reducer: {
+      settings: settingsSlice.reducer,
+      lodes: lodesSlice.reducer,
+      specs: specsSlice.reducer,
     },
-    reducer: { settings: settingsSlice.reducer },
   })

package/src/utils/adaptorUtils.ts

@@ -0,0 +1,181 @@
+/*
+
+ MIT License
+
+ Copyright (c) 2021 Looker Data Sciences, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+ */
+
+import type { ILookerVersions, SpecItem, SpecList } from '@looker/sdk-codegen'
+import { ApiModel, upgradeSpecObject } from '@looker/sdk-codegen'
+import { api_spec } from '@looker/sdk'
+import { getEnvAdaptor } from '@looker/extension-utils'
+import type { RunItValues } from '@looker/run-it'
+import { getUrl } from '@looker/run-it'
+
+export type StorageLocation = 'session' | 'local'
+
+/** Object returned from storage service */
+export interface IStorageValue {
+  /** Location of the stored object */
+  location: StorageLocation
+  /** Stored string representation of the value (usually JSON) */
+  value: string
+}
+
+/** function to retrieve a spec based on version and name */
+export type ApiSpecFetcher = (
+  version: string,
+  name: string
+) => Promise<string | RunItValues>
+
+/** Either the spec is parsed or it's undefined */
+export type ParsedSpec = ApiModel | undefined
+
+/** service abstraction for extension and browser based usage */
+export interface RunItConfigurator {
+  getStorage: (key: string, defaultValue?: string) => IStorageValue
+  setStorage(key: string, value: string, location: 'local' | 'session'): string
+  removeStorage(key: string): void
+}
+
+/** Processed specifications */
+export interface ILoadedSpecs {
+  /** API server url */
+  baseUrl: string
+  /** Web server url */
+  webUrl: string
+  /** should APIX run headless? */
+  headless: boolean
+  /** loaded specifications */
+  specs: SpecList
+  /** communication errors */
+  fetchResult: string
+}
+
+/** Extends versions payload with headless toggle for API Explorer */
+export interface IAPIXConfig extends ILookerVersions {
+  headless?: boolean
+}
+
+/**
+ * Convert content into an ApiModel
+ * @param content to convert
+ */
+const makeApi = (content: string | RunItValues) => {
+  let json
+  if (typeof content === 'string') {
+    json = JSON.parse(content)
+  } else {
+    json = content
+  }
+  json = upgradeSpecObject(json)
+  return ApiModel.fromJson(json)
+}
+
+/**
+ * Ensure the URI is a full URL
+ * @param uri possible relative path
+ * @param baseUrl base url for qualifying full path
+ */
+export const fullify = (uri: string, baseUrl: string): string => {
+  if (uri.match(/^https?:/)) {
+    return uri
+  }
+  const url = new URL(uri, baseUrl)
+  return url.toString()
+}
+/**
+ * parse spec url into version and name for api_spec cccall
+ * @param spec to parse
+ */
+const apiSpecBits = (spec: SpecItem): string[] =>
+  spec.specURL?.split('/').slice(-2) || []
+
+/**
+ * Use the functional api_spec fetch
+ * @param version to retrieve
+ * @param name to retrieve
+ */
+export const funFetch = (version: string, name: string): Promise<string> => {
+  const sdk = getEnvAdaptor().sdk
+  return sdk.ok(api_spec(sdk, version, name))
+}
+
+/**
+ * try to fetch a spec by URL, trap any errors and return undefined
+ * @param url to convert to an API spec
+ */
+export const specUrlFetch = async (url: string): Promise<ParsedSpec> => {
+  try {
+    const content = await getUrl(url)
+    return makeApi(content)
+  } catch (error) {
+    return undefined
+  }
+}
+
+/**
+ * fetch and compile an API specification to an ApiModel if it's not already available
+ *
+ * **NOTE**: This uses Looker API 4.0 to fetch the specification so fetch works with CORS
+ *
+ * @param spec to fetch and compile
+ * @param fetcher function to retrieve API spec content
+ */
+export const sdkSpecFetch = async (
+  spec: SpecItem,
+  fetcher: ApiSpecFetcher
+): Promise<ParsedSpec> => {
+  if (spec.api) return spec.api
+  if (!spec.specURL) return undefined
+  const [version, name] = apiSpecBits(spec)
+  const content = await fetcher(version, name)
+  return makeApi(content)
+}
+
+/** Attempt to retrieve spec by URL, then api_spec SDK call
+ *
+ * @param spec to fetch
+ * @param fetcher function to retrieve and parse spec
+ */
+export const fallbackFetch = async (
+  spec: SpecItem,
+  fetcher: ApiSpecFetcher
+): Promise<ParsedSpec> => {
+  if (spec.api) return spec.api
+  if (!spec.specURL) return undefined
+  let api: ParsedSpec
+  try {
+    api = await specUrlFetch(spec.specURL)
+  } catch (error) {
+    console.error({ error })
+  }
+  if (!api) {
+    const sdk = getEnvAdaptor().sdk
+    const authed = sdk.authSession.isAuthenticated()
+    if (!authed) {
+      await sdk.authSession.login()
+    }
+    api = await sdkSpecFetch(spec, fetcher)
+  }
+  return api
+}

package/src/utils/apixAdaptor.ts

@@ -0,0 +1,72 @@
+/*
+
+ MIT License
+
+ Copyright (c) 2021 Looker Data Sciences, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+ */
+import type { IEnvironmentAdaptor } from '@looker/extension-utils'
+import { BrowserAdaptor, getEnvAdaptor } from '@looker/extension-utils'
+import type { IAPIMethods } from '@looker/sdk-rtl'
+import type { SpecItem, SpecList } from '@looker/sdk-codegen'
+import { getSpecsFromVersions } from '@looker/sdk-codegen'
+import { RunItConfigKey, RunItNoConfig } from '@looker/run-it'
+import cloneDeep from 'lodash/cloneDeep'
+
+import { fullify, fallbackFetch, funFetch } from './adaptorUtils'
+
+export interface IApixAdaptor extends IEnvironmentAdaptor {
+  fetchSpecList(versionsUrl?: string): Promise<SpecList>
+  fetchSpec(spec: SpecItem): Promise<SpecItem>
+}
+
+export const getApixAdaptor = () => getEnvAdaptor() as IApixAdaptor
+
+export class ApixAdaptor extends BrowserAdaptor implements IApixAdaptor {
+  constructor(sdk: IAPIMethods, private readonly fallbackVersionsUrl: string) {
+    super(sdk)
+  }
+
+  async fetchSpecList(versionsUrl?: string): Promise<SpecList> {
+    const data = await this.localStorageGetItem(RunItConfigKey)
+    const config = data ? JSON.parse(data) : RunItNoConfig
+    let url: string
+
+    if (versionsUrl) {
+      url = versionsUrl
+    } else {
+      url = config.base_url
+        ? `${config.base_url}/versions`
+        : `${this.fallbackVersionsUrl}/versions.json`
+    }
+
+    const versions = await this.sdk.authSession.transport.rawRequest('GET', url)
+    const specs = await getSpecsFromVersions(JSON.parse(versions.body))
+    return specs
+  }
+
+  async fetchSpec(spec: SpecItem): Promise<SpecItem> {
+    const _spec = cloneDeep(spec)
+    _spec.specURL = fullify(spec.specURL!, origin)
+    _spec.api = await fallbackFetch(_spec, funFetch)
+    return _spec
+  }
+}

package/src/utils/index.ts

@@ -24,13 +24,8 @@
 
  */
 export { highlightHTML } from './highlight'
-export {
-  buildPath,
-  buildMethodPath,
-  buildTypePath,
-  diffPath,
-  oAuthPath,
-} from './path'
+export * from './path'
 export { getLoded } from './lodeUtils'
 export { useWindowSize } from './useWindowSize'
-export * from './envAdaptor'
+export * from './apixAdaptor'
+export * from './adaptorUtils'