[Console] Filter autocomplete endpoints by availability

config/serverless.yml

@@ -62,3 +62,6 @@ xpack.spaces.allowFeatureVisibility: false
 # Temporarily allow unauthenticated access to task manager utilization & status/stats APIs for autoscaling
 status.allowAnonymous: true
 xpack.task_manager.unsafe.authenticate_background_task_utilization: false
+
+# Only display console autocomplete suggestions for ES endpoints that are available in serverless
+console.autocompleteDefinitions.endpointsAvailability: serverless

packages/kbn-generate-console-definitions/src/generate_console_definitions.ts

@@ -14,6 +14,7 @@ import type {
   AutocompleteBodyParams,
   AutocompleteDefinition,
   AutocompleteUrlParams,
+  AutocompleteAvailability,
   SpecificationTypes,
 } from './types';
 import { findTypeDefinition } from './utils';
@@ -65,6 +66,23 @@ const generateBodyParams = (
   return {};
 };
 
+const DEFAULT_STACK_ENDPOINT_AVAILABILITY = true;
+const DEFAULT_SERVERLESS_ENDPOINT_AVAILABILITY = true;
+
+const generateAvailability = (endpoint: SpecificationTypes.Endpoint): AutocompleteAvailability => {
+  const availability: AutocompleteAvailability = {
+    stack: DEFAULT_STACK_ENDPOINT_AVAILABILITY,
+    serverless: DEFAULT_SERVERLESS_ENDPOINT_AVAILABILITY,
+  };
+  if (endpoint.availability.stack?.visibility) {
+    availability.stack = endpoint.availability.stack?.visibility === 'public';
+  }
+  if (endpoint.availability.serverless?.visibility) {
+    availability.serverless = endpoint.availability.serverless?.visibility === 'public';
+  }
+  return availability;
+};
+
 const addParams = (
   definition: AutocompleteDefinition,
   params: { urlParams: AutocompleteUrlParams; bodyParams: AutocompleteBodyParams }
@@ -86,12 +104,13 @@ const generateDefinition = (
   const methods = generateMethods(endpoint);
   const patterns = generatePatterns(endpoint);
   const documentation = generateDocumentation(endpoint);
+  const availability = generateAvailability(endpoint);
   let definition: AutocompleteDefinition = {};
   const params = generateParams(endpoint, schema);
   if (params) {
     definition = addParams(definition, params);
   }
-  definition = { ...definition, methods, patterns, documentation };
+  definition = { ...definition, methods, patterns, documentation, availability };
 
   return definition;
 };

packages/kbn-generate-console-definitions/src/types/autocomplete_definition_types.ts

@@ -14,10 +14,16 @@ export interface AutocompleteBodyParams {
   [key: string]: number | string;
 }
 
+export interface AutocompleteAvailability {
+  stack: boolean;
+  serverless: boolean;
+}
+
 export interface AutocompleteDefinition {
   documentation?: string;
   methods?: string[];
   patterns?: string[];
   url_params?: AutocompleteUrlParams;
   data_autocomplete_rules?: AutocompleteBodyParams;
+  availability?: AutocompleteAvailability;
 }

packages/kbn-generate-console-definitions/src/types/index.ts

@@ -10,6 +10,7 @@ export type {
   AutocompleteDefinition,
   AutocompleteUrlParams,
   AutocompleteBodyParams,
+  AutocompleteAvailability,
 } from './autocomplete_definition_types';
 
 export * as SpecificationTypes from './specification_types';

src/plugins/console/server/config.ts

@@ -24,13 +24,19 @@ const schemaLatest = schema.object(
     ui: schema.object({
       enabled: schema.boolean({ defaultValue: true }),
     }),
+    autocompleteDefinitions: schema.object({
+      // Only displays the endpoints that are available in the specified environment
+      // Current supported values are 'stack' and 'serverless'
+      endpointsAvailability: schema.string({ defaultValue: 'stack' }),
+    }),
   },
   { defaultValue: undefined }
 );
 
 const configLatest: PluginConfigDescriptor<ConsoleConfig> = {
   exposeToBrowser: {
     ui: true,
+    autocompleteDefinitions: true,
   },
   schema: schemaLatest,
   deprecations: () => [],

src/plugins/console/server/plugin.ts

@@ -83,7 +83,10 @@ export class ConsoleServerPlugin implements Plugin<ConsoleSetup, ConsoleStart> {
   }
 
   start() {
-    this.specDefinitionsService.start();
+    const {
+      autocompleteDefinitions: { endpointsAvailability: endpointsAvailability },
+    } = this.ctx.config.get<ConsoleConfig>();
+    this.specDefinitionsService.start({ endpointsAvailability });
   }
 
   stop() {

src/plugins/console/server/services/spec_definitions_service.ts

@@ -22,6 +22,11 @@ interface EndpointDescription {
   data_autocomplete_rules?: Record<string, unknown>;
   url_components?: Record<string, unknown>;
   priority?: number;
+  availability?: Record<string, boolean>;
+}
+
+export interface SpecDefinitionsDependencies {
+  endpointsAvailability: string;
 }
 
 export class SpecDefinitionsService {
@@ -92,9 +97,9 @@ export class SpecDefinitionsService {
     };
   }
 
-  public start() {
+  public start({ endpointsAvailability }: SpecDefinitionsDependencies) {
     if (!this.hasLoadedSpec) {
-      this.loadJsonSpec();
+      this.loadJsonSpec(endpointsAvailability);
       this.loadJSSpec();
       this.hasLoadedSpec = true;
     } else {
@@ -127,14 +132,20 @@ export class SpecDefinitionsService {
     }, {} as Record<string, EndpointDescription>);
   }
 
-  private loadJsonSpec() {
+  private loadJsonSpec(endpointsAvailability: string) {
     const result = this.loadJSONSpecInDir(AUTOCOMPLETE_DEFINITIONS_FOLDER);
     this.extensionSpecFilePaths.forEach((extensionSpecFilePath) => {
       merge(result, this.loadJSONSpecInDir(extensionSpecFilePath));
     });
 
     Object.keys(result).forEach((endpoint) => {
-      this.addEndpointDescription(endpoint, result[endpoint]);
+      const description = result[endpoint];
+      const addEndpoint =
+        (endpointsAvailability === 'stack' && description.availability?.stack) ||
+        (endpointsAvailability === 'serverless' && description.availability?.serverless);
+      if (addEndpoint) {
+        this.addEndpointDescription(endpoint, description);
+      }
     });
   }