@finos/legend-application 4.0.3 → 5.1.0

package/src/stores/LegendApplicationAssistantService.ts

@@ -15,10 +15,7 @@
  */
 
 import { action, makeObservable, observable, computed } from 'mobx';
-import type {
-  LegendApplicationContextualDocumentationEntry,
-  LegendApplicationDocumentationEntry,
-} from './LegendApplicationDocumentationService.js';
+import type { LegendApplicationDocumentationEntry } from './LegendApplicationDocumentationService.js';
 import type { LegendApplicationConfig } from './LegendApplicationConfig.js';
 import type { ApplicationStore } from './ApplicationStore.js';
 import { Fuse } from './CJS__Fuse.cjs';
@@ -69,13 +66,14 @@ export class VirtualAssistantContextualDocumentationEntry {
   related: VirtualAssistantDocumentationEntry[];
 
   constructor(
-    contextualDocEntry: LegendApplicationContextualDocumentationEntry,
+    context: string,
+    docEntry: LegendApplicationDocumentationEntry,
     related: VirtualAssistantDocumentationEntry[],
   ) {
-    this.context = contextualDocEntry._context;
-    this.title = contextualDocEntry.title;
-    this.content = contextualDocEntry.markdownText ?? contextualDocEntry.text;
-    this.url = contextualDocEntry.url;
+    this.context = context;
+    this.title = docEntry.title;
+    this.content = docEntry.markdownText ?? docEntry.text;
+    this.url = docEntry.url;
     this.related = related;
   }
 }
@@ -83,6 +81,10 @@ export class VirtualAssistantContextualDocumentationEntry {
 export class LegendApplicationAssistantService {
   readonly applicationStore: ApplicationStore<LegendApplicationConfig>;
   private readonly searchEngine: Fuse<LegendApplicationDocumentationEntry>;
+  /**
+   * This key is used to allow programmatic re-rendering of the assistant panel
+   */
+  panelRenderingKey = uuid();
   isHidden = false;
   isOpen = false;
   selectedTab = VIRTUAL_ASSISTANT_TAB.SEARCH;
@@ -95,6 +97,7 @@ export class LegendApplicationAssistantService {
     makeObservable(this, {
       isHidden: observable,
       isOpen: observable,
+      panelRenderingKey: observable,
       selectedTab: observable,
       searchText: observable,
       searchResults: observable,
@@ -105,6 +108,7 @@ export class LegendApplicationAssistantService {
       setSearchText: action,
       resetSearch: action,
       search: action,
+      refreshPanelRendering: action,
     });
 
     this.applicationStore = applicationStore;
@@ -147,16 +151,20 @@ export class LegendApplicationAssistantService {
   get currentContextualDocumentationEntry():
     | VirtualAssistantContextualDocumentationEntry
     | undefined {
-    const currentContextualDocumentationEntry = this.applicationStore
-      .navigationContextService.currentContext
-      ? this.applicationStore.documentationService.getContextualDocEntry(
-          this.applicationStore.navigationContextService.currentContext.value,
-        )
-      : undefined;
+    if (!this.applicationStore.navigationContextService.currentContext) {
+      return undefined;
+    }
+    const currentContext =
+      this.applicationStore.navigationContextService.currentContext.value;
+    const currentContextualDocumentationEntry =
+      this.applicationStore.documentationService.getContextualDocEntry(
+        currentContext,
+      );
     return currentContextualDocumentationEntry
       ? new VirtualAssistantContextualDocumentationEntry(
+          currentContext,
           currentContextualDocumentationEntry,
-          currentContextualDocumentationEntry.related
+          (currentContextualDocumentationEntry.related ?? [])
             .map((entry) =>
               this.applicationStore.documentationService.getDocEntry(entry),
             )
@@ -165,6 +173,8 @@ export class LegendApplicationAssistantService {
               (entry) =>
                 // NOTE: since we're searching for user-friendly docs, we will discard anything that
                 // doesn't come with a title, or does not have any content/url
+                //
+                // We could also consider having a flag in each documentation entry to be hidden from users
                 entry.title && (entry.url ?? entry.text ?? entry.markdownText),
             )
             .map((entry) => new VirtualAssistantDocumentationEntry(entry)),
@@ -198,6 +208,10 @@ export class LegendApplicationAssistantService {
     this.selectedTab = val;
   }
 
+  refreshPanelRendering(): void {
+    this.panelRenderingKey = uuid();
+  }
+
   setSearchText(val: string): void {
     this.searchText = val;
   }

package/src/stores/LegendApplicationConfig.ts

@@ -18,13 +18,15 @@ import {
   guaranteeNonEmptyString,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
+import type { LegendApplicationConfigurationInput } from '../index.js';
 import {
-  type LegendApplicationKeyedDocumentationEntry,
-  type LegendApplicationDocumentationEntryConfig,
-  type LegendApplicationKeyedContextualDocumentationEntry,
-  type LegendApplicationContextualDocumentationEntryConfig,
   collectKeyedDocumnetationEntriesFromConfig,
-  collectKeyedContextualDocumentationEntriesFromConfig,
+  collectContextualDocumnetationEntry,
+  type LegendApplicationKeyedDocumentationEntry,
+  type LegendApplicationDocumentationConfigEntry,
+  type LegendApplicationContextualDocumentationMapConfig,
+  type LegendApplicationContextualDocumentationEntry,
+  type LegendApplicationDocumentationRegistryEntry,
 } from './LegendApplicationDocumentationService.js';
 
 export interface LegendApplicationVersionData {
@@ -38,13 +40,11 @@ export interface LegendApplicationConfigurationData {
   env: string;
   documentation?: {
     url: string;
-    entries?: Record<string, LegendApplicationDocumentationEntryConfig>;
-    contextualEntries?: Record<
-      string,
-      LegendApplicationContextualDocumentationEntryConfig
-    >;
+    registry?: LegendApplicationDocumentationRegistryEntry[];
+    entries?: Record<string, LegendApplicationDocumentationConfigEntry>;
+    contextualDocMap?: LegendApplicationContextualDocumentationMapConfig;
   };
-  // TODO: when we support vault-like settings
+  // TODO: when we support vault-like settings, we could support `settingOverrides`
   // See https://github.com/finos/legend-studio/issues/407
   // settingOverrides
   extensions?: Record<PropertyKey, unknown>;
@@ -57,9 +57,11 @@ export abstract class LegendApplicationConfig {
 
   // documentation
   readonly documentationUrl: string | undefined;
+  readonly documentationRegistryEntries: LegendApplicationDocumentationRegistryEntry[] =
+    [];
   readonly keyedDocumentationEntries: LegendApplicationKeyedDocumentationEntry[] =
     [];
-  readonly keyedContextualDocumentationEntries: LegendApplicationKeyedContextualDocumentationEntry[] =
+  readonly contextualDocEntries: LegendApplicationContextualDocumentationEntry[] =
     [];
 
   // version
@@ -68,41 +70,40 @@ export abstract class LegendApplicationConfig {
   readonly appVersionCommitId: string;
 
   constructor(
-    configData: LegendApplicationConfigurationData,
-    versionData: LegendApplicationVersionData,
-    baseUrl: string,
+    input: LegendApplicationConfigurationInput<LegendApplicationConfigurationData>,
   ) {
-    this.baseUrl = baseUrl;
+    this.baseUrl = input.baseUrl;
     this.appName = guaranteeNonEmptyString(
-      configData.appName,
+      input.configData.appName,
       `Can't configure application: 'appName' field is missing or empty`,
     );
     this.env = guaranteeNonEmptyString(
-      configData.env,
+      input.configData.env,
       `Can't configure application: 'env' field is missing or empty`,
     );
 
     // Documentation
-    this.documentationUrl = configData.documentation?.url;
+    this.documentationUrl = input.configData.documentation?.url;
+    this.documentationRegistryEntries =
+      input.configData.documentation?.registry ?? [];
     this.keyedDocumentationEntries = collectKeyedDocumnetationEntriesFromConfig(
-      configData.documentation?.entries ?? {},
+      input.configData.documentation?.entries ?? {},
+    );
+    this.contextualDocEntries = collectContextualDocumnetationEntry(
+      input.configData.documentation?.contextualDocMap ?? {},
     );
-    this.keyedContextualDocumentationEntries =
-      collectKeyedContextualDocumentationEntriesFromConfig(
-        configData.documentation?.contextualEntries ?? {},
-      );
 
     // Version
     this.appVersion = guaranteeNonNullable(
-      versionData.version,
+      input.versionData.version,
       `Can't collect application version: 'version' field is missing`,
     );
     this.appVersionBuildTime = guaranteeNonNullable(
-      versionData.buildTime,
+      input.versionData.buildTime,
       `Can't collect application version: 'buildTime' field is missing`,
     );
     this.appVersionCommitId = guaranteeNonNullable(
-      versionData.commitSHA,
+      input.versionData.commitSHA,
       `Can't collect application version: 'commitSHA' field is missing`,
     );
   }

package/src/stores/LegendApplicationDocumentationService.ts

@@ -21,7 +21,6 @@ import {
   SerializationFactory,
   LogEvent,
   uniq,
-  guaranteeNonNullable,
 } from '@finos/legend-shared';
 import {
   createModelSchema,
@@ -34,11 +33,34 @@ import { APPLICATION_EVENT } from './ApplicationEvent.js';
 import type { ApplicationStore } from './ApplicationStore.js';
 import type { LegendApplicationConfig } from './LegendApplicationConfig.js';
 
-export type LegendApplicationDocumentationEntryConfig = {
+export type LegendApplicationDocumentationRegistryEntry = {
+  url: string;
+  /**
+   * Sometimes, we don't need to expose an endpoint to get the documentation data
+   * we support the `simple` mode where the endpoint is really just a JSON
+   *
+   * The caveat about this mode is that the endpoint must have CORS enabled
+   * ideally, the CORS-enabled endpoint should be setup with "Access-Control-Allow-Origin", "*"
+   * (e.g. Github Pages - See https://stackoverflow.com/questions/26416727/cross-origin-resource-sharing-on-github-pages)
+   * With that, the network client used to fetch this request must also be simplified to not include credential
+   * See https://stackoverflow.com/questions/19743396/cors-cannot-use-wildcard-in-access-control-allow-origin-when-credentials-flag-i
+   *
+   * During development, an option is to use our mock-server or some sort of CORS proxies, for example `cors-anywhere`
+   * See https://cors-anywhere.herokuapp.com/
+   */
+  simple?: boolean | undefined;
+};
+
+export type LegendApplicationDocumentationRegistryData = {
+  entries: Record<string, LegendApplicationDocumentationConfigEntry>;
+};
+
+export type LegendApplicationDocumentationConfigEntry = {
   markdownText?: MarkdownText | undefined;
   title?: string | undefined;
   text?: string | undefined;
   url?: string | undefined;
+  related?: string[] | undefined;
 };
 
 export class LegendApplicationDocumentationEntry {
@@ -48,6 +70,7 @@ export class LegendApplicationDocumentationEntry {
   title?: string | undefined;
   text?: string | undefined;
   url?: string | undefined;
+  related?: string[] | undefined;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(LegendApplicationDocumentationEntry, {
@@ -55,6 +78,7 @@ export class LegendApplicationDocumentationEntry {
         (val) => val,
         (val) => (val.value ? val : undefined),
       ),
+      related: optional(list(primitive())),
       title: optional(primitive()),
       text: optional(primitive()),
       url: optional(primitive()),
@@ -73,100 +97,70 @@ export class LegendApplicationDocumentationEntry {
   }
 }
 
-export type LegendApplicationContextualDocumentationEntryConfig =
-  LegendApplicationDocumentationEntryConfig & {
-    related?: string[];
-  };
-
-export class LegendApplicationContextualDocumentationEntry {
-  readonly _context!: string;
-
-  markdownText?: MarkdownText | undefined;
-  title?: string | undefined;
-  text?: string | undefined;
-  url?: string | undefined;
-  related: string[] = [];
-
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(LegendApplicationContextualDocumentationEntry, {
-      markdownText: custom(
-        (val) => val,
-        (val) => (val.value ? val : undefined),
-      ),
-      title: optional(primitive()),
-      text: optional(primitive()),
-      url: optional(primitive()),
-      related: list(primitive()),
-    }),
-  );
-
-  static create(
-    json: PlainObject<LegendApplicationContextualDocumentationEntry>,
-    context: string,
-  ): LegendApplicationContextualDocumentationEntry {
-    const entry =
-      LegendApplicationContextualDocumentationEntry.serialization.fromJson(
-        json,
-      );
-    (
-      entry as Writable<LegendApplicationContextualDocumentationEntry>
-    )._context = context;
-    return entry;
-  }
-}
-
-export interface LegendApplicationKeyedContextualDocumentationEntry {
-  key: string;
-  content: LegendApplicationContextualDocumentationEntry;
-}
-
-export const collectKeyedContextualDocumentationEntriesFromConfig = (
-  rawEntries: Record<
-    string,
-    LegendApplicationContextualDocumentationEntryConfig
-  >,
-): LegendApplicationKeyedContextualDocumentationEntry[] =>
-  Object.entries(rawEntries).map((entry) => ({
-    key: entry[0],
-    content: LegendApplicationContextualDocumentationEntry.create(
-      entry[1],
-      entry[0],
-    ),
-  }));
-
 export interface LegendApplicationKeyedDocumentationEntry {
   key: string;
   content: LegendApplicationDocumentationEntry;
 }
 
 export const collectKeyedDocumnetationEntriesFromConfig = (
-  rawEntries: Record<string, LegendApplicationDocumentationEntryConfig>,
+  rawEntries: Record<string, LegendApplicationDocumentationConfigEntry>,
 ): LegendApplicationKeyedDocumentationEntry[] =>
   Object.entries(rawEntries).map((entry) => ({
     key: entry[0],
     content: LegendApplicationDocumentationEntry.create(entry[1], entry[0]),
   }));
 
+export type LegendApplicationContextualDocumentationMapConfig = Record<
+  string,
+  string
+>;
+export type LegendApplicationContextualDocumentationEntry = {
+  context: string;
+  documentationKey: string;
+};
+export const collectContextualDocumnetationEntry = (
+  contextualDocMap: LegendApplicationContextualDocumentationMapConfig,
+): LegendApplicationContextualDocumentationEntry[] =>
+  Object.entries(contextualDocMap).map((entry) => ({
+    context: entry[0],
+    documentationKey: entry[1],
+  }));
+
 export class LegendApplicationDocumentationService {
   url?: string | undefined;
 
   private docRegistry = new Map<string, LegendApplicationDocumentationEntry>();
-  private contextualDocRegistry = new Map<
+  private contextualDocMap = new Map<
     string,
-    LegendApplicationContextualDocumentationEntry
+    LegendApplicationDocumentationEntry
   >();
 
   constructor(applicationStore: ApplicationStore<LegendApplicationConfig>) {
+    // set the main documenation site url
+    this.url = applicationStore.config.documentationUrl;
+
+    /**
+     * NOTE: the order of documentation entry overidding is (the later override the former):
+     * 1. Natively specified: specified in the codebase (no overriding allowed within this group of documentation entries):
+     *    since we have extension mechanism, the order of plugins matter,
+     *    we do not allow overriding, i.e. so the first specification for a documentation key wins
+     * 2. Fetched from documentation registries (no overriding allowed within this group of documentation entries):
+     *    since we have extension mechanism and allow specifying multiple registry URLS,
+     *    we do not allow overriding, i.e. so the first specification for a documentation key wins
+     * 3. Configured in application config (overiding allowed within this group)
+     */
+
+    // build doc registry
     applicationStore.pluginManager
       .getApplicationPlugins()
       .flatMap((plugin) => plugin.getExtraKeyedDocumentationEntries?.() ?? [])
       .forEach((entry) => {
-        // Entries specified natively will not override each other. This is to prevent entries from extensions
-        // overriding entries from core.
+        // NOTE: Entries specified natively will not override each other. This is to prevent entries from extensions
+        // accidentally overide entries from core.
         if (this.hasDocEntry(entry.key)) {
           applicationStore.log.warn(
             LogEvent.create(
-              APPLICATION_EVENT.APPLICATION_DOCUMTENTION_LOAD_SKIPPED,
+              APPLICATION_EVENT.APPLICATION_DOCUMENTATION_LOAD_SKIPPED,
             ),
             entry.key,
           );
@@ -174,55 +168,71 @@ export class LegendApplicationDocumentationService {
           this.docRegistry.set(entry.key, entry.content);
         }
       });
+
     // entries from config will override entries specified natively
     applicationStore.config.keyedDocumentationEntries.forEach((entry) =>
       this.docRegistry.set(entry.key, entry.content),
     );
 
-    // Contextual Documentation
-    applicationStore.pluginManager
+    const contextualDocEntries = applicationStore.pluginManager
       .getApplicationPlugins()
       .flatMap(
-        (plugin) =>
-          plugin.getExtraKeyedContextualDocumentationEntries?.() ?? [],
-      )
-      .forEach((entry) => {
-        // Entries specified natively will not override each other. This is to prevent entries from extensions
-        // overriding entries from core. However, we will merge the list of related doc entries. This allows
-        // extensions to broaden related doc entries for certain contexts
-        if (this.hasContextualDocEntry(entry.key)) {
-          applicationStore.log.warn(
-            LogEvent.create(
-              APPLICATION_EVENT.APPLICATION_CONTEXTUAL_DOCUMTENTION_LOAD_SKIPPED,
-            ),
-            entry.key,
-          );
-          const existingEntry = guaranteeNonNullable(
-            this.getContextualDocEntry(entry.key),
-          );
-          existingEntry.related = uniq([
-            ...existingEntry.related,
-            ...entry.content.related,
-          ]);
-        } else {
-          this.contextualDocRegistry.set(entry.key, entry.content);
+        (plugin) => plugin.getExtraContextualDocumentationEntries?.() ?? [],
+      );
+
+    // verify that required documentations are available
+    const missingDocumentationEntries: string[] = [];
+    uniq(
+      applicationStore.pluginManager
+        .getApplicationPlugins()
+        .flatMap((plugin) => plugin.getExtraRequiredDocumentationKeys?.() ?? [])
+        .concat(contextualDocEntries.map((entry) => entry.documentationKey)),
+    ).forEach((key) => {
+      if (!this.docRegistry.has(key)) {
+        missingDocumentationEntries.push(key);
+      }
+    });
+    if (missingDocumentationEntries.length) {
+      applicationStore.log.warn(
+        LogEvent.create(
+          APPLICATION_EVENT.APPLICATION_DOCUMENTATION_REQUIREMENT_CHECK_FAILURE,
+        ),
+        `Can't find corresponding documentation entry for keys:\n${missingDocumentationEntries
+          .map((key) => `- ${key}`)
+          .join('\n')}`,
+      );
+    }
+
+    // Contextual Documentation
+    contextualDocEntries.forEach((entry) => {
+      // NOTE: Entries specified natively will not override each other. This is to prevent entries from extensions
+      // overriding entries from core.
+      //
+      // However, it might be useful to allow extending the list of related doc entries.
+      // This allows extensions to broaden related doc entries for contextual docs
+      // If we need to support this behavior, we could create a dedicated extension method
+      if (this.hasContextualDocEntry(entry.context)) {
+        applicationStore.log.warn(
+          LogEvent.create(
+            APPLICATION_EVENT.APPLICATION_CONTEXTUAL_DOCUMENTATION_LOAD_SKIPPED,
+          ),
+          entry.context,
+        );
+      } else {
+        const existingDocEntry = this.getDocEntry(entry.documentationKey);
+        if (existingDocEntry) {
+          this.contextualDocMap.set(entry.context, existingDocEntry);
         }
-      });
+      }
+    });
+
     // entries from config will override entries specified natively
-    // however, we will keep merging related doc entries list
-    applicationStore.config.keyedContextualDocumentationEntries.forEach(
-      (entry) => {
-        const existingEntry = this.getContextualDocEntry(entry.key);
-        if (existingEntry) {
-          entry.content.related = uniq([
-            ...existingEntry.related,
-            ...entry.content.related,
-          ]);
-        }
-        this.contextualDocRegistry.set(entry.key, entry.content);
-      },
-    );
-    this.url = applicationStore.config.documentationUrl;
+    applicationStore.config.contextualDocEntries.forEach((entry) => {
+      const existingDocEntry = this.getDocEntry(entry.documentationKey);
+      if (existingDocEntry) {
+        this.contextualDocMap.set(entry.context, existingDocEntry);
+      }
+    });
   }
 
   getDocEntry(key: string): LegendApplicationDocumentationEntry | undefined {
@@ -235,12 +245,12 @@ export class LegendApplicationDocumentationService {
 
   getContextualDocEntry(
     key: string,
-  ): LegendApplicationContextualDocumentationEntry | undefined {
-    return this.contextualDocRegistry.get(key);
+  ): LegendApplicationDocumentationEntry | undefined {
+    return this.contextualDocMap.get(key);
   }
 
   hasContextualDocEntry(key: string): boolean {
-    return this.contextualDocRegistry.has(key);
+    return this.contextualDocMap.has(key);
   }
 
   getAllDocEntries(): LegendApplicationDocumentationEntry[] {
@@ -249,9 +259,9 @@ export class LegendApplicationDocumentationService {
 
   publishDocRegistry(): Record<
     string,
-    LegendApplicationDocumentationEntryConfig
+    LegendApplicationDocumentationConfigEntry
   > {
-    const result: Record<string, LegendApplicationDocumentationEntryConfig> =
+    const result: Record<string, LegendApplicationDocumentationConfigEntry> =
       {};
     this.docRegistry.forEach((value, key) => {
       result[key] =
@@ -260,16 +270,10 @@ export class LegendApplicationDocumentationService {
     return result;
   }
 
-  publishContextualDocRegistry(): object {
-    const result: Record<
-      string,
-      LegendApplicationContextualDocumentationEntryConfig
-    > = {};
-    this.contextualDocRegistry.forEach((value, key) => {
-      result[key] =
-        LegendApplicationContextualDocumentationEntry.serialization.toJson(
-          value,
-        );
+  publishContextualDocMap(): LegendApplicationContextualDocumentationMapConfig {
+    const result: LegendApplicationContextualDocumentationMapConfig = {};
+    this.contextualDocMap.forEach((value, key) => {
+      result[key] = value._documentationKey;
     });
     return result;
   }

package/src/stores/LegendApplicationPlugin.ts

@@ -16,18 +16,32 @@
 
 import { AbstractPlugin } from '@finos/legend-shared';
 import type {
-  LegendApplicationKeyedContextualDocumentationEntry,
+  LegendApplicationContextualDocumentationEntry,
+  LegendApplicationDocumentationRegistryEntry,
   LegendApplicationKeyedDocumentationEntry,
 } from './LegendApplicationDocumentationService.js';
 
 export abstract class LegendApplicationPlugin extends AbstractPlugin {
+  /**
+   * Get the list of documentation registry entries from which the application can fetch
+   * documentation config data and load the documentation registry
+   */
+  getExtraDocumentationRegistryEntries?(): LegendApplicationDocumentationRegistryEntry[];
+
   /**
    * Get the list of keyed documentation entries to be registered with documentation service.
    */
   getExtraKeyedDocumentationEntries?(): LegendApplicationKeyedDocumentationEntry[];
 
   /**
-   * Get the list of keyed contextual documentation entries to be registered with documentation service.
+   * Get the list of documentation keys whose corresponding documentation entry is required
+   * in the application. The documentation registry will be scanned for the presence of these,
+   * if they are not available, warnings will be issued.
+   */
+  getExtraRequiredDocumentationKeys?(): string[];
+
+  /**
+   * Get the list of contextual documentation entries to be registered with documentation service.
    */
-  getExtraKeyedContextualDocumentationEntries?(): LegendApplicationKeyedContextualDocumentationEntry[];
+  getExtraContextualDocumentationEntries?(): LegendApplicationContextualDocumentationEntry[];
 }

package/src/stores/PureLanguageSupport.ts

@@ -137,15 +137,20 @@ const generateLanguageMonarch = (
       PURE_CONNECTION_NAME.JSON_MODEL_CONNECTION,
       PURE_CONNECTION_NAME.MODEL_CHAIN_CONNECTION,
       PURE_CONNECTION_NAME.XML_MODEL_CONNECTION,
-      PURE_CONNECTION_NAME.FLAT_DATA_CONNECTION,
-      PURE_CONNECTION_NAME.RELATIONAL_DATABASE_CONNECTION,
       // mapping
+      'include',
       'EnumerationMapping',
       'Pure',
-      'Relational', // to be modularized
       'AssociationMapping',
       'XStore',
       'AggregationAware',
+      /**
+       * @modularize
+       * See https://github.com/finos/legend-studio/issues/65
+       */
+      PURE_CONNECTION_NAME.FLAT_DATA_CONNECTION,
+      PURE_CONNECTION_NAME.RELATIONAL_DATABASE_CONNECTION,
+      'Relational',
     ],
 
     operators: [