[Lens] Show underlying data embeddable

x-pack/plugins/lens/public/app_plugin/show_underlying_data.ts

@@ -53,7 +53,10 @@ export function getLayerMetaInfo(
   currentDatasource: Datasource | undefined,
   datasourceState: unknown,
   activeData: TableInspectorAdapter | undefined,
-  capabilities: RecursiveReadonly<Capabilities>
+  capabilities: RecursiveReadonly<{
+    navLinks: Capabilities['navLinks'];
+    discover?: Capabilities['discover'];
+  }>
 ): { meta: LayerMetaInfo | undefined; isVisible: boolean; error: string | undefined } {
   const isVisible = Boolean(capabilities.navLinks?.discover && capabilities.discover?.show);
   // If Multiple tables, return

x-pack/plugins/lens/public/editor_frame_service/service.tsx

@@ -61,7 +61,7 @@ export class EditorFrameService {
   private readonly datasources: Array<Datasource | (() => Promise<Datasource>)> = [];
   private readonly visualizations: Array<Visualization | (() => Promise<Visualization>)> = [];
 
-  private loadDatasources = () => collectAsyncDefinitions(this.datasources);
+  public loadDatasources = () => collectAsyncDefinitions(this.datasources);
   public loadVisualizations = () => collectAsyncDefinitions(this.visualizations);
 
   /**

x-pack/plugins/lens/public/embeddable/embeddable.tsx

@@ -21,7 +21,7 @@ import {
 import type { PaletteOutput } from 'src/plugins/charts/public';
 import type { Start as InspectorStart } from 'src/plugins/inspector/public';
 
-import { Subscription } from 'rxjs';
+import { Subject, Subscription } from 'rxjs';
 import { toExpression, Ast } from '@kbn/interpreter';
 import { RenderMode } from 'src/plugins/expressions';
 import { map, distinctUntilChanged, skip } from 'rxjs/operators';
@@ -56,21 +56,25 @@ import {
   LensTableRowContextMenuEvent,
   VisualizationMap,
   Visualization,
+  DatasourceMap,
+  Datasource,
 } from '../types';
 
 import { IndexPatternsContract } from '../../../../../src/plugins/data/public';
 import { getEditPath, DOC_TYPE, PLUGIN_ID } from '../../common';
 import type {
+  Capabilities,
   IBasePath,
   KibanaExecutionContext,
   ThemeServiceStart,
 } from '../../../../../src/core/public';
 import { LensAttributeService } from '../lens_attribute_service';
-import type { ErrorMessage } from '../editor_frame_service/types';
+import type { ErrorMessage, TableInspectorAdapter } from '../editor_frame_service/types';
 import { getLensInspectorService, LensInspector } from '../lens_inspector_service';
 import { SharingSavedObjectProps } from '../types';
 import type { SpacesPluginStart } from '../../../spaces/public';
-import { inferTimeField } from '../utils';
+import { getActiveDatasourceIdFromDoc, getIndexPatternsObjects, inferTimeField } from '../utils';
+import { getLayerMetaInfo, combineQueryAndFilters } from '../app_plugin/show_underlying_data';
 
 export type LensSavedObjectAttributes = Omit<Document, 'savedObjectId' | 'type'>;
 
@@ -115,19 +119,33 @@ export interface LensEmbeddableDeps {
   ) => Promise<{ ast: Ast | null; errors: ErrorMessage[] | undefined }>;
   injectFilterReferences: FilterManager['inject'];
   visualizationMap: VisualizationMap;
+  datasourceMap: DatasourceMap;
   indexPatternService: IndexPatternsContract;
   expressionRenderer: ReactExpressionRendererType;
   timefilter: TimefilterContract;
   basePath: IBasePath;
   inspector: InspectorStart;
   getTrigger?: UiActionsStart['getTrigger'] | undefined;
   getTriggerCompatibleActions?: UiActionsStart['getTriggerCompatibleActions'];
-  capabilities: { canSaveVisualizations: boolean; canSaveDashboards: boolean };
+  capabilities: {
+    canSaveVisualizations: boolean;
+    canSaveDashboards: boolean;
+    navLinks: Capabilities['navLinks'];
+    discover?: Capabilities['discover'];
+  };
   usageCollection?: UsageCollectionSetup;
   spaces?: SpacesPluginStart;
   theme: ThemeServiceStart;
 }
 
+export interface ViewUnderlyingDataArgs {
+  indexPatternId: string;
+  timeRange: TimeRange;
+  filters: Filter[];
+  query: Query | undefined;
+  columns: string[];
+}
+
 const getExpressionFromDocument = async (
   document: Document,
   documentToExpression: LensEmbeddableDeps['documentToExpression']
@@ -139,6 +157,52 @@ const getExpressionFromDocument = async (
   };
 };
 
+function getViewUnderlyingDataArgs({
+  activeDatasource,
+  activeDatasourceState,
+  activeData,
+  indexPatterns,
+  capabilities,
+  query,
+  filters,
+  timeRange,
+}: {
+  activeDatasource: Datasource;
+  activeDatasourceState: unknown;
+  activeData: TableInspectorAdapter | undefined;
+  indexPatterns: IndexPattern[];
+  capabilities: LensEmbeddableDeps['capabilities'];
+  query: Query;
+  filters: Filter[];
+  timeRange: TimeRange;
+}) {
+  const { error, meta } = getLayerMetaInfo(
+    activeDatasource,
+    activeDatasourceState,
+    activeData,
+    capabilities
+  );
+
+  if (error || !meta) {
+    return;
+  }
+
+  const { filters: newFilters, query: newQuery } = combineQueryAndFilters(
+    query,
+    filters,
+    meta,
+    indexPatterns
+  );
+
+  return {
+    indexPatternId: meta.id,
+    timeRange,
+    filters: newFilters,
+    query: newQuery,
+    columns: meta.columns,
+  };
+}
+
 export class Embeddable
   extends AbstractEmbeddable<LensEmbeddableInput, LensEmbeddableOutput>
   implements ReferenceOrValueEmbeddable<LensByValueInput, LensByReferenceInput>
@@ -167,13 +231,26 @@ export class Embeddable
     );
   }
 
-  private externalSearchContext: {
+  private externalSearchContext?: {
     timeRange?: TimeRange;
     query?: Query;
     filters?: Filter[];
     searchSessionId?: string;
+  };
+
+  private activeDataInfo: {
+    activeData?: TableInspectorAdapter;
+    activeDatasource?: Datasource;
+    activeDatasourceState?: unknown;
   } = {};
 
+  private indexPatterns: IndexPattern[] = [];
+
+  private viewUnderlyingDataArgs?: ViewUnderlyingDataArgs;
+
+  private waitVUDArgsLoaded: Promise<boolean>;
+  private markVUDArgsLoaded: (loaded: boolean) => void;
+
   constructor(
     private deps: LensEmbeddableDeps,
     initialInput: LensEmbeddableInput,
@@ -186,9 +263,29 @@ export class Embeddable
       },
       parent
     );
+
+    const _vudSubscription = new Subject<boolean>();
+
+    this.markVUDArgsLoaded = (loaded: boolean) => {
+      _vudSubscription.next(loaded);
+      _vudSubscription.complete();
+    };
+
+    this.waitVUDArgsLoaded = new Promise<boolean>((resolve) => {
+      const subscription = _vudSubscription.subscribe((loaded) => {
+        resolve(loaded);
+        subscription.unsubscribe();
+      });
+    });
+
     this.lensInspector = getLensInspectorService(deps.inspector);
     this.expressionRenderer = deps.expressionRenderer;
-    this.initializeSavedVis(initialInput).then(() => this.onContainerStateChanged(initialInput));
+    this.initializeSavedVis(initialInput)
+      .then(() => this.initializeOutput())
+      .then(() => {
+        this.isInitialized = true;
+        this.onContainerStateChanged(initialInput);
+      });
     this.subscription = this.getUpdated$().subscribe(() =>
       this.onContainerStateChanged(this.input)
     );
@@ -355,9 +452,6 @@ export class Embeddable
     );
     this.expression = expression;
     this.errors = this.maybeAddConflictError(errors, metaInfo?.sharingSavedObjectProps);
-
-    await this.initializeOutput();
-    this.isInitialized = true;
   }
 
   onContainerStateChanged(containerState: LensEmbeddableInput) {
@@ -370,10 +464,10 @@ export class Embeddable
       ? containerState.filters.filter((filter) => !filter.meta.disabled)
       : undefined;
     if (
-      !isEqual(containerState.timeRange, this.externalSearchContext.timeRange) ||
-      !isEqual(containerState.query, this.externalSearchContext.query) ||
-      !isEqual(cleanedFilters, this.externalSearchContext.filters) ||
-      this.externalSearchContext.searchSessionId !== containerState.searchSessionId ||
+      !isEqual(containerState.timeRange, this.externalSearchContext?.timeRange) ||
+      !isEqual(containerState.query, this.externalSearchContext?.query) ||
+      !isEqual(cleanedFilters, this.externalSearchContext?.filters) ||
+      this.externalSearchContext?.searchSessionId !== containerState.searchSessionId ||
       this.embeddableTitle !== this.getTitle()
     ) {
       this.externalSearchContext = {
@@ -383,12 +477,15 @@ export class Embeddable
         searchSessionId: containerState.searchSessionId,
       };
       this.embeddableTitle = this.getTitle();
+      this.updateViewUnderlyingDataArgs();
       isDirty = true;
     }
     return isDirty;
   }
 
-  private updateActiveData: ExpressionWrapperProps['onData$'] = () => {
+  private updateActiveData: ExpressionWrapperProps['onData$'] = (_, adapters) => {
+    this.activeDataInfo.activeData = adapters?.tables?.tables;
+    this.updateViewUnderlyingDataArgs();
     if (this.input.onLoad) {
       // once onData$ is get's called from expression renderer, loading becomes false
       this.input.onLoad(false);
@@ -598,29 +695,79 @@ export class Embeddable
     }
   }
 
+  private async updateViewUnderlyingDataArgs() {
+    if (!this.activeDataInfo.activeData || !this.externalSearchContext) {
+      // This function is called both when activeData and externalSearchContext are loaded
+      // because we're not sure which one will load first. But, both must be loaded before
+      // we actually run this.
+      return;
+    }
+
+    const activeDatasourceId = getActiveDatasourceIdFromDoc(this.savedVis);
+    if (activeDatasourceId) {
+      this.activeDataInfo.activeDatasource = this.deps.datasourceMap[activeDatasourceId];
+      const docDatasourceState = this.savedVis?.state.datasourceStates[activeDatasourceId];
+
+      this.activeDataInfo.activeDatasourceState =
+        await this.activeDataInfo.activeDatasource.initialize(
+          docDatasourceState,
+          this.savedVis?.references
+        );
+    }
+
+    const viewUnderlyingDataArgs = getViewUnderlyingDataArgs({
+      activeDatasource: this.activeDataInfo.activeDatasource!,
+      activeDatasourceState: this.activeDataInfo.activeDatasourceState,
+      activeData: this.activeDataInfo.activeData,
+      indexPatterns: this.indexPatterns!,
+      capabilities: this.deps.capabilities,
+      query: this.externalSearchContext.query!,
+      filters: this.externalSearchContext.filters!,
+      timeRange: this.externalSearchContext.timeRange!,
+    });
+
+    const loaded = typeof viewUnderlyingDataArgs !== 'undefined';
+
+    if (loaded) {
+      this.viewUnderlyingDataArgs = viewUnderlyingDataArgs;
+    }
+
+    this.markVUDArgsLoaded(loaded);
+  }
+
+  /**
+   * Returns the necessary arguments to view the underlying data in discover.
+   */
+  public async getViewUnderlyingDataArgs() {
+    const loaded = await this.waitVUDArgsLoaded;
+    if (loaded) {
+      return this.viewUnderlyingDataArgs;
+    }
+  }
+
+  public getCanViewUnderlyingData() {
+    // if loading the underlying data args fails
+    return this.waitVUDArgsLoaded;
+  }
+
   async initializeOutput() {
     if (!this.savedVis) {
       return;
     }
-    const responses = await Promise.allSettled(
-      uniqBy(
-        this.savedVis.references.filter(({ type }) => type === 'index-pattern'),
-        'id'
-      ).map(({ id }) => this.deps.indexPatternService.get(id))
+
+    const { indexPatterns } = await getIndexPatternsObjects(
+      this.savedVis?.references.map(({ id }) => id) || [],
+      this.deps.indexPatternService
     );
-    const indexPatterns = responses
-      .filter(
-        (response): response is PromiseFulfilledResult<IndexPattern> =>
-          response.status === 'fulfilled'
-      )
-      .map(({ value }) => value);
+
+    this.indexPatterns = indexPatterns;
 
     // passing edit url and index patterns to the output of this embeddable for
     // the container to pick them up and use them to configure filter bar and
     // config dropdown correctly.
     const input = this.getInput();
 
-    this.errors = this.maybeAddTimeRangeError(this.errors, input, indexPatterns);
+    this.errors = this.maybeAddTimeRangeError(this.errors, input, this.indexPatterns);
 
     if (this.errors) {
       this.logError('validation');
@@ -635,7 +782,7 @@ export class Embeddable
       title,
       editPath: getEditPath(savedObjectId),
       editUrl: this.deps.basePath.prepend(`/app/lens${getEditPath(savedObjectId)}`),
-      indexPatterns,
+      indexPatterns: this.indexPatterns,
     });
 
     // deferred loading of this embeddable is complete

x-pack/plugins/lens/public/embeddable/embeddable_factory.ts

@@ -29,7 +29,7 @@ import { DOC_TYPE } from '../../common/constants';
 import { ErrorMessage } from '../editor_frame_service/types';
 import { extract, inject } from '../../common/embeddable_factory';
 import type { SpacesPluginStart } from '../../../spaces/public';
-import { VisualizationMap } from '../types';
+import { DatasourceMap, VisualizationMap } from '../types';
 
 export interface LensEmbeddableStartServices {
   timefilter: TimefilterContract;
@@ -46,6 +46,7 @@ export interface LensEmbeddableStartServices {
   ) => Promise<{ ast: Ast | null; errors: ErrorMessage[] | undefined }>;
   injectFilterReferences: FilterManager['inject'];
   visualizationMap: VisualizationMap;
+  datasourceMap: DatasourceMap;
   spaces?: SpacesPluginStart;
   theme: ThemeServiceStart;
 }
@@ -95,6 +96,7 @@ export class EmbeddableFactory implements EmbeddableFactoryDefinition {
       documentToExpression,
       injectFilterReferences,
       visualizationMap,
+      datasourceMap,
       uiActions,
       coreHttp,
       attributeService,
@@ -121,9 +123,12 @@ export class EmbeddableFactory implements EmbeddableFactoryDefinition {
         documentToExpression,
         injectFilterReferences,
         visualizationMap,
+        datasourceMap,
         capabilities: {
           canSaveDashboards: Boolean(capabilities.dashboard?.showWriteControls),
           canSaveVisualizations: Boolean(capabilities.visualize.save),
+          navLinks: capabilities.navLinks,
+          discover: capabilities.discover,
         },
         usageCollection,
         theme,