@finos/legend-application-studio 28.7.1 → 28.8.0

package/src/stores/editor/EditorSDLCState.ts

@@ -48,7 +48,6 @@ import {
   Workspace,
   WorkspaceAccessType,
   Patch,
-  ProjectAccessRole,
   AuthorizableProjectAction,
 } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
@@ -77,7 +76,6 @@ export class EditorSDLCState {
   projectVersions: Version[] = [];
   projectPublishedVersions: string[] = [];
   authorizedActions: AuthorizableProjectAction[] | undefined;
-  accessRole: ProjectAccessRole | undefined;
 
   constructor(editorStore: EditorStore) {
     makeObservable(this, {
@@ -94,7 +92,6 @@ export class EditorSDLCState {
       isFetchingProject: observable,
       projectPublishedVersions: observable,
       authorizedActions: observable,
-      accessRole: observable,
       activeProject: computed,
       activeWorkspace: computed,
       activeRevision: computed,
@@ -174,12 +171,9 @@ export class EditorSDLCState {
   }
 
   unAuthorizedActionMessage(_action: AuthorizableProjectAction): string {
-    if (this.accessRole) {
-      return `Your role ${
-        this.accessRole.accessRole
-      } does not allow you to perform the action '${prettyCONSTName(_action)}'`;
-    }
-    return `Your are not entitled to perform the action: ${_action}`;
+    return `Your are not entitled to perform the action: ${prettyCONSTName(
+      _action,
+    )}`;
   }
 
   userCanPerformAction(authorizedAction: AuthorizableProjectAction): boolean {
@@ -568,26 +562,19 @@ export class EditorSDLCState {
 
   *fetchAuthorizedActions(): GeneratorFn<void> {
     try {
-      const [authorizedActions, accessRoleRaw] = (yield Promise.all([
-        this.editorStore.sdlcServerClient.getAutorizedActions(
-          this.activeProject.projectId,
-        ),
-        this.editorStore.sdlcServerClient.getAccessRole(
+      const authorizedActions =
+        (yield this.editorStore.sdlcServerClient.getAutorizedActions(
           this.activeProject.projectId,
-        ),
-      ])) as [AuthorizableProjectAction[], PlainObject<ProjectAccessRole>];
+        )) as AuthorizableProjectAction[];
       this.authorizedActions = authorizedActions;
-      this.accessRole = ProjectAccessRole.serialization.fromJson(accessRoleRaw);
     } catch (error) {
       assertErrorThrown(error);
       // if there is an error fetching authorized actions we should set undefined
       this.authorizedActions = undefined;
-      this.accessRole = undefined;
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
         error,
       );
-      this.editorStore.applicationStore.notificationService.notifyError(error);
     }
   }
 

package/src/stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderState.ts

@@ -30,6 +30,7 @@ import {
   guaranteeType,
   assertNonEmptyString,
   assertTrue,
+  UnsupportedOperationError,
 } from '@finos/legend-shared';
 import {
   observable,
@@ -42,9 +43,18 @@ import {
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../__lib__/LegendStudioEvent.js';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
+  type RawLambda,
+  type PureModel,
+  type Runtime,
+  type ExecutionResult,
+  TDSExecutionResult,
+  getColumn,
+  PrimitiveType,
+  PRIMITIVE_TYPE,
+  TDSRow,
   type Schema,
-  type Table,
-  type RelationalDatabaseConnection,
+  Table,
+  RelationalDatabaseConnection,
   DatabaseBuilderInput,
   DatabasePattern,
   TargetDatabase,
@@ -57,9 +67,173 @@ import {
   isStubbed_PackageableElement,
   isValidFullPath,
   PackageableElementExplicitReference,
+  getTable,
+  Mapping,
+  EngineRuntime,
+  StoreConnections,
+  IdentifiedConnection,
 } from '@finos/legend-graph';
 import { GraphEditFormModeState } from '../../../GraphEditFormModeState.js';
 import { connection_setStore } from '../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
+import { getTDSColumnDerivedProperyFromType } from '@finos/legend-query-builder';
+import { getPrimitiveTypeFromRelationalType } from '../../../utils/MockDataUtils.js';
+
+const GENERATED_PACKAGE = 'generated';
+const TDS_LIMIT = 1000;
+
+const buildTableToTDSQueryGrammar = (table: Table): string => {
+  const tableName = table.name;
+  const schemaName = table.schema.name;
+  const db = table.schema._OWNER.path;
+  return `|${db}->tableReference(
+    '${schemaName}',
+    '${tableName}'
+  )->tableToTDS()->take(${TDS_LIMIT})`;
+};
+
+const buildTableToTDSQueryNonNumericWithColumnGrammar = (
+  column: Column,
+): string => {
+  const table = guaranteeType(column.owner, Table);
+  const tableName = table.name;
+  const colName = column.name;
+  const schemaName = table.schema.name;
+  const db = table.schema._OWNER.path;
+  const PREVIEW_COLUMN_NAME = 'Count Value';
+  const columnGetter = getTDSColumnDerivedProperyFromType(
+    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING,
+  );
+  return `|${db}->tableReference(
+    '${schemaName}',
+    '${tableName}'
+  )->tableToTDS()->restrict(
+    ['${colName}']
+  )->groupBy(
+    ['${colName}'],
+    '${PREVIEW_COLUMN_NAME}'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      y|$y->count()
+    )
+  )->sort(
+    [
+      desc('${colName}'),
+      asc('${PREVIEW_COLUMN_NAME}')
+    ]
+  )->take(${TDS_LIMIT})`;
+};
+
+const buildTableToTDSQueryNumericWithColumnGrammar = (
+  column: Column,
+): string => {
+  const table = guaranteeType(column.owner, Table);
+  const tableName = table.name;
+  const colName = column.name;
+  const schemaName = table.schema.name;
+  const db = table.schema._OWNER.path;
+  const columnGetter = getTDSColumnDerivedProperyFromType(
+    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING,
+  );
+  return `|${db}->tableReference(
+    '${schemaName}',
+    '${tableName}'
+  )->tableToTDS()->restrict(
+    ['${colName}']
+  )->groupBy(
+    [],
+    [
+      'Count'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->count()
+    ),
+      'Distinct Count'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->distinct()->count()
+    ),
+      'Sum'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->sum()
+    ),
+      'Min'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->min()
+    ),
+      'Max'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->max()
+    ),
+      'Average'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->average()
+    ),
+      'Std Dev (Population)'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->stdDevPopulation()
+    ),
+      'Std Dev (Sample)'->agg(
+      row|$row.${columnGetter}('${colName}'),
+      x|$x->stdDevSample()
+    )
+    ]
+  )`;
+};
+
+const buildTableToTDSQueryColumnQuery = (column: Column): [string, boolean] => {
+  const type =
+    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING;
+  const numerics = [
+    PRIMITIVE_TYPE.NUMBER,
+    PRIMITIVE_TYPE.INTEGER,
+    PRIMITIVE_TYPE.DECIMAL,
+    PRIMITIVE_TYPE.FLOAT,
+  ];
+  if (numerics.includes(type.path as PRIMITIVE_TYPE)) {
+    return [buildTableToTDSQueryNumericWithColumnGrammar(column), true];
+  }
+
+  return [buildTableToTDSQueryNonNumericWithColumnGrammar(column), false];
+};
+
+// 1. mapping
+// 2. connection
+// 3. runtime
+
+const buildTDSModel = (
+  graph: PureModel,
+  connection: RelationalDatabaseConnection,
+  db: Database,
+): {
+  mapping: Mapping;
+  runtime: Runtime;
+} => {
+  // mapping
+  const mappingName = 'EmptyMapping';
+  const _mapping = new Mapping(mappingName);
+  graph.addElement(_mapping, GENERATED_PACKAGE);
+  const engineRuntime = new EngineRuntime();
+  engineRuntime.mappings = [
+    PackageableElementExplicitReference.create(_mapping),
+  ];
+  const _storeConnection = new StoreConnections(
+    PackageableElementExplicitReference.create(db),
+  );
+  // copy over new connection
+  const newconnection = new RelationalDatabaseConnection(
+    PackageableElementExplicitReference.create(db),
+    connection.type,
+    connection.datasourceSpecification,
+    connection.authenticationStrategy,
+  );
+  newconnection.localMode = connection.localMode;
+  newconnection.timeZone = connection.timeZone;
+  _storeConnection.storeConnections = [
+    new IdentifiedConnection('connection1', newconnection),
+  ];
+  engineRuntime.connections = [_storeConnection];
+  return {
+    runtime: engineRuntime,
+    mapping: _mapping,
+  };
+};
 
 export abstract class DatabaseSchemaExplorerTreeNodeData
   implements TreeNodeData
@@ -138,6 +312,8 @@ export class DatabaseSchemaExplorerState {
   isGeneratingDatabase = false;
   isUpdatingDatabase = false;
   treeData?: DatabaseExplorerTreeData | undefined;
+  previewer: TDSExecutionResult | undefined;
+  previewDataState = ActionState.create();
 
   constructor(
     editorStore: EditorStore,
@@ -148,6 +324,8 @@ export class DatabaseSchemaExplorerState {
       isUpdatingDatabase: observable,
       treeData: observable,
       targetDatabasePath: observable,
+      previewer: observable,
+      previewDataState: observable,
       isCreatingNewDatabase: computed,
       resolveDatabasePackageAndName: computed,
       setTreeData: action,
@@ -158,6 +336,7 @@ export class DatabaseSchemaExplorerState {
       fetchTableMetadata: flow,
       generateDatabase: flow,
       updateDatabase: flow,
+      previewData: flow,
     });
 
     this.connection = connection;
@@ -455,6 +634,113 @@ export class DatabaseSchemaExplorerState {
     );
   }
 
+  *previewData(node: DatabaseSchemaExplorerTreeNodeData): GeneratorFn<void> {
+    try {
+      this.previewer = undefined;
+      this.previewDataState.inProgress();
+      let column: Column | undefined;
+      let table: Table | undefined;
+      if (node instanceof DatabaseSchemaExplorerTreeTableNodeData) {
+        table = node.table;
+      } else if (node instanceof DatabaseSchemaExplorerTreeColumnNodeData) {
+        table = guaranteeType(node.column.owner, Table);
+        column = node.column;
+      } else {
+        throw new UnsupportedOperationError(
+          'Preview data only supported for column and table',
+        );
+      }
+      const schemaName = table.schema.name;
+      const tableName = table.name;
+      const dummyPackage = 'generation';
+      const dummyName = 'myDB';
+      const dummyDbPath = `${dummyPackage}::${dummyName}`;
+      const databaseBuilderInput = new DatabaseBuilderInput(this.connection);
+      databaseBuilderInput.targetDatabase = new TargetDatabase(
+        dummyPackage,
+        dummyName,
+      );
+      const config = databaseBuilderInput.config;
+      config.maxTables = undefined;
+      config.enrichTables = true;
+      config.enrichColumns = true;
+      config.enrichPrimaryKeys = true;
+      config.patterns.push(new DatabasePattern(table.schema.name, table.name));
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.buildDatabase(
+          databaseBuilderInput,
+        )) as Entity[];
+      assertTrue(entities.length === 1);
+      const dbEntity = guaranteeNonNullable(entities[0]);
+      const emptyGraph = this.editorStore.graphManagerState.createNewGraph();
+      (yield this.editorStore.graphManagerState.graphManager.buildGraph(
+        emptyGraph,
+        [dbEntity],
+        ActionState.create(),
+      )) as Entity[];
+      const generatedDb = emptyGraph.getDatabase(dummyDbPath);
+      const resolvedTable = getTable(
+        getSchema(generatedDb, schemaName),
+        tableName,
+      );
+      let queryGrammar: string;
+      let resolveResult = false;
+      if (column) {
+        const resolvedColumn = getColumn(resolvedTable, column.name);
+        const grammarResult = buildTableToTDSQueryColumnQuery(resolvedColumn);
+        queryGrammar = grammarResult[0];
+        resolveResult = grammarResult[1];
+      } else {
+        queryGrammar = buildTableToTDSQueryGrammar(resolvedTable);
+      }
+      const rawLambda =
+        (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+          queryGrammar,
+          'QUERY',
+        )) as RawLambda;
+      const { mapping, runtime } = buildTDSModel(
+        emptyGraph,
+        this.connection,
+        generatedDb,
+      );
+      const execPlan =
+        (yield this.editorStore.graphManagerState.graphManager.runQuery(
+          rawLambda,
+          mapping,
+          runtime,
+          emptyGraph,
+        )) as ExecutionResult;
+      let tdsResult = guaranteeType(
+        execPlan,
+        TDSExecutionResult,
+        'Execution from `tabletoTDS` expected to be TDS',
+      );
+      if (resolveResult) {
+        const newResult = new TDSExecutionResult();
+        newResult.result.columns = ['Aggregation', 'Value'];
+        newResult.result.rows = tdsResult.result.columns.map((col, idx) => {
+          const _row = new TDSRow();
+          _row.values = [
+            col,
+            guaranteeNonNullable(
+              guaranteeNonNullable(tdsResult.result.rows[0]).values[idx],
+            ),
+          ];
+          return _row;
+        });
+        tdsResult = newResult;
+      }
+      this.previewer = tdsResult;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Unable to preview data: ${error.message}`,
+      );
+    } finally {
+      this.previewDataState.complete();
+    }
+  }
+
   *generateDatabase(): GeneratorFn<Entity> {
     try {
       this.isGeneratingDatabase = true;

package/src/stores/editor/editor-state/element-editor-state/connection/DatabaseModelBuilderState.ts

@@ -25,11 +25,9 @@ import {
 import { observable, action, makeObservable, flow, flowResult } from 'mobx';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../__lib__/LegendStudioEvent.js';
 import type { EditorStore } from '../../../EditorStore.js';
-import type { Database } from '@finos/legend-graph';
+import { type Database, DEFAULT_GENERATION_PACKAGE } from '@finos/legend-graph';
 import { EntityChangeType, type EntityChange } from '@finos/legend-server-sdlc';
 
-export const GENERATED = 'generated';
-
 export class DatabaseModelBuilderState {
   readonly editorStore: EditorStore;
   readonly database: Database;
@@ -64,7 +62,7 @@ export class DatabaseModelBuilderState {
     this.editorStore = editorStore;
     this.database = database;
     this.isReadOnly = isReadOnly;
-    this.targetPackage = database.package?.path ?? GENERATED;
+    this.targetPackage = database.package?.path ?? DEFAULT_GENERATION_PACKAGE;
   }
 
   setShowModal(val: boolean): void {
@@ -98,7 +96,6 @@ export class DatabaseModelBuilderState {
           this.targetPackage,
           this.editorStore.graphManagerState.graph,
         )) as Entity[];
-
       this.setEntities(entities);
       this.setDatabaseGrammarCode(
         (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(

package/src/stores/editor/editor-state/element-editor-state/database/QueryDatabaseState.ts

@@ -0,0 +1,234 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  DEFAULT_GENERATION_PACKAGE,
+  EngineRuntime,
+  Database,
+  RelationalDatabaseConnection,
+  PackageableElementExplicitReference,
+  StoreConnections,
+  IdentifiedConnection,
+  GraphManagerState,
+  getMappingCompatibleClasses,
+} from '@finos/legend-graph';
+import type { EditorStore } from '../../../EditorStore.js';
+import {
+  ActionState,
+  assertErrorThrown,
+  guaranteeNonNullable,
+  type GeneratorFn,
+  assertTrue,
+} from '@finos/legend-shared';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import type { Entity } from '@finos/legend-storage';
+import {
+  QueryBuilderConfig,
+  QueryBuilderState,
+} from '@finos/legend-query-builder';
+import {
+  DEFAULT_TAB_SIZE,
+  type GenericLegendApplicationStore,
+} from '@finos/legend-application';
+import { payloadDebugger } from '../../../panel-group/DevToolPanelState.js';
+import { renderDatabaseQueryBuilderSetupPanelContent } from '../../../../../components/editor/editor-group/database/IsolatedQueryDatabase.js';
+
+const replaceConnectionInEngineRuntime = (
+  engineRuntime: EngineRuntime,
+  connection: RelationalDatabaseConnection,
+  databse: Database,
+): void => {
+  const _storeConnection = new StoreConnections(
+    PackageableElementExplicitReference.create(databse),
+  );
+  const newconnection = new RelationalDatabaseConnection(
+    PackageableElementExplicitReference.create(databse),
+    connection.type,
+    connection.datasourceSpecification,
+    connection.authenticationStrategy,
+  );
+  newconnection.localMode = connection.localMode;
+  newconnection.timeZone = connection.timeZone;
+  _storeConnection.storeConnections = [
+    new IdentifiedConnection('connection1', newconnection),
+  ];
+  engineRuntime.connections = [_storeConnection];
+};
+export class IsolatedDatabaseBuilderState extends QueryBuilderState {
+  readonly database: Database;
+  globalGraphManagerState: GraphManagerState;
+  engineRuntime: EngineRuntime;
+  connectionKey: string;
+  compatibleConnections: Map<string, RelationalDatabaseConnection>;
+
+  override TEMPORARY__setupPanelContentRenderer = (): React.ReactNode =>
+    renderDatabaseQueryBuilderSetupPanelContent(this);
+
+  constructor(
+    applicationStore: GenericLegendApplicationStore,
+    isolatedGraphManagerState: GraphManagerState,
+    globalGraphManagerState: GraphManagerState,
+    database: Database,
+    connectionKey: string,
+    runtime: EngineRuntime,
+    compatibleConnections: Map<string, RelationalDatabaseConnection>,
+    acceptedElementPaths?: string[],
+    config?: QueryBuilderConfig | undefined,
+  ) {
+    super(applicationStore, isolatedGraphManagerState, config);
+    makeObservable(this, {
+      connectionKey: observable,
+      engineRuntime: observable,
+      changeConnection: action,
+    });
+    this.database = database;
+    this.globalGraphManagerState = globalGraphManagerState;
+    this.engineRuntime = runtime;
+    this.compatibleConnections = compatibleConnections;
+    this.connectionKey = connectionKey;
+    const classes = isolatedGraphManagerState.usableClasses;
+    const electedMapping = guaranteeNonNullable(
+      isolatedGraphManagerState.graph.mappings.filter((m) =>
+        acceptedElementPaths ? acceptedElementPaths.includes(m.path) : true,
+      )[0],
+      'Compatible mapping expected',
+    );
+
+    this.class = guaranteeNonNullable(
+      getMappingCompatibleClasses(electedMapping, classes)[0],
+      'Compatible class expected for mapping',
+    );
+
+    this.executionContextState.mapping = electedMapping;
+    this.executionContextState.runtimeValue = runtime;
+  }
+
+  changeConnection(key: string): void {
+    const connection = this.compatibleConnections.get(key);
+    if (connection) {
+      replaceConnectionInEngineRuntime(
+        this.engineRuntime,
+        connection,
+        this.database,
+      );
+      this.connectionKey = key;
+    }
+  }
+}
+
+export class QueryDatabaseState {
+  editorStore: EditorStore;
+  database: Database;
+
+  constructor(database: Database, editorStore: EditorStore) {
+    this.database = database;
+    this.editorStore = editorStore;
+
+    makeObservable(this, {
+      init: flow,
+    });
+  }
+  *init(): GeneratorFn<void> {
+    try {
+      const compConnections = new Map<string, RelationalDatabaseConnection>();
+      this.editorStore.graphManagerState.usableConnections.forEach((conn) => {
+        const val = conn.connectionValue;
+        if (val instanceof RelationalDatabaseConnection) {
+          compConnections.set(conn.path, val);
+        }
+      });
+      assertTrue(
+        compConnections.size > 0,
+        `No compatible connections found for database ${this.database.path}`,
+      );
+      const embeddedQueryBuilderState =
+        this.editorStore.embeddedQueryBuilderState;
+      const databaseGraphManagerState = new GraphManagerState(
+        this.editorStore.applicationStore.pluginManager,
+        this.editorStore.applicationStore.logService,
+      );
+      yield databaseGraphManagerState.graphManager.initialize(
+        {
+          env: this.editorStore.applicationStore.config.env,
+          tabSize: DEFAULT_TAB_SIZE,
+          clientConfig: {
+            baseUrl: this.editorStore.applicationStore.config.engineServerUrl,
+            queryBaseUrl:
+              this.editorStore.applicationStore.config.engineQueryServerUrl,
+            enableCompression: true,
+            payloadDebugger,
+          },
+        },
+        {
+          tracerService: this.editorStore.applicationStore.tracerService,
+        },
+      );
+      databaseGraphManagerState.graph =
+        this.editorStore.graphManagerState.createNewGraph();
+      const copiedDb = new Database(this.database.name);
+      databaseGraphManagerState.graph.addElement(
+        copiedDb,
+        guaranteeNonNullable(this.database.package?.path),
+      );
+      copiedDb.schemas = this.database.schemas;
+      copiedDb.joins = this.database.joins;
+      copiedDb.filters = this.database.filters;
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.generateModelsFromDatabaseSpecification(
+          this.database.path,
+          DEFAULT_GENERATION_PACKAGE,
+          this.editorStore.graphManagerState.graph,
+        )) as Entity[];
+      yield this.editorStore.graphManagerState.graphManager.buildGraph(
+        databaseGraphManagerState.graph,
+        entities,
+        ActionState.create(),
+      );
+      const engineRuntime = new EngineRuntime();
+      engineRuntime.mappings = databaseGraphManagerState.graph.mappings.map(
+        (e) => PackageableElementExplicitReference.create(e),
+      );
+      const connectionEntry = guaranteeNonNullable(
+        Array.from(compConnections.entries())[0],
+      );
+      const connection = connectionEntry[1];
+      replaceConnectionInEngineRuntime(engineRuntime, connection, copiedDb);
+      const config = new QueryBuilderConfig();
+      const queryBuilderState = new IsolatedDatabaseBuilderState(
+        this.editorStore.applicationStore,
+        databaseGraphManagerState,
+        this.editorStore.graphManagerState,
+        copiedDb,
+        connectionEntry[0],
+        engineRuntime,
+        compConnections,
+        entities.map((e) => e.path),
+        config,
+      );
+      yield flowResult(
+        embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration({
+          setupQueryBuilderState: () => queryBuilderState,
+          actionConfigs: [],
+        }),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Unable to query database: ${error.message}`,
+      );
+    }
+  }
+}

package/src/stores/project-view/ProjectViewerStore.ts

@@ -274,6 +274,7 @@ export class ProjectViewerStore {
     yield Promise.all([
       this.editorStore.sdlcState.fetchProjectVersions(),
       this.editorStore.sdlcState.fetchPublishedProjectVersions(),
+      this.editorStore.sdlcState.fetchAuthorizedActions(),
     ]);
 
     // fetch entities

package/tsconfig.json

@@ -101,6 +101,7 @@
     "./src/stores/editor/editor-state/element-editor-state/connection/PostProcessorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/data/DataEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/data/EmbeddedDataState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/database/QueryDatabaseState.ts",
     "./src/stores/editor/editor-state/element-editor-state/external-format/DSL_ExternalFormat_BindingEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/external-format/DSL_ExternalFormat_SchemaSetEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/DEPRECATED__MappingTestState.ts",
@@ -206,6 +207,7 @@
     "./src/components/editor/editor-group/data-editor/DataElementEditor.tsx",
     "./src/components/editor/editor-group/data-editor/EmbeddedDataEditor.tsx",
     "./src/components/editor/editor-group/data-editor/RelationalCSVDataEditor.tsx",
+    "./src/components/editor/editor-group/database/IsolatedQueryDatabase.tsx",
     "./src/components/editor/editor-group/diff-editor/EntityChangeConflictEditor.tsx",
     "./src/components/editor/editor-group/diff-editor/EntityDiffView.tsx",
     "./src/components/editor/editor-group/element-generation-editor/ElementGenerationEditor.tsx",