@finos/legend-application-studio 28.7.1 → 28.9.0

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/editor/editor-state/element-editor-state/mapping/testable/MappingTestableState.ts

@@ -81,6 +81,7 @@ import {
   createBareMappingTest,
   createGraphFetchQueryFromMappingAnalysis,
   generateStoreTestDataFromSetImpl,
+  isRelationalMappingTestSuite,
 } from './MappingTestingHelper.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../../__lib__/LegendStudioEvent.js';
 
@@ -729,15 +730,36 @@ export class MappingTestableState {
       this.selectedTestSuite?.testStates.forEach((t) =>
         t.runningTestAction.inProgress(),
       );
-      const input = new RunTestsTestableInput(this.mapping);
-      suite.tests.forEach((t) =>
-        input.unitTestIds.push(new UniqueTestId(suite, t)),
-      );
-      const testResults =
-        (yield this.editorStore.graphManagerState.graphManager.runTests(
-          [input],
-          this.editorStore.graphManagerState.graph,
-        )) as TestResult[];
+      let testResults: TestResult[];
+      if (isRelationalMappingTestSuite(suite)) {
+        // TEMPORARY RUN each test separately. This is done to help with performance
+        // specifically with running realtional mapping tests as we generate a plan during each test.
+        // with this change we would still do this but in parallel reducing the time to run the suite
+        const inputs = suite.tests.map((t) => {
+          const input = new RunTestsTestableInput(this.mapping);
+          input.unitTestIds.push(new UniqueTestId(suite, t));
+          return input;
+        });
+        const _testResults = (yield Promise.all(
+          inputs.map((i) =>
+            this.editorStore.graphManagerState.graphManager.runTests(
+              [i],
+              this.editorStore.graphManagerState.graph,
+            ),
+          ),
+        )) as TestResult[][];
+        testResults = _testResults.flat();
+      } else {
+        const input = new RunTestsTestableInput(this.mapping);
+        suite.tests.forEach((t) =>
+          input.unitTestIds.push(new UniqueTestId(suite, t)),
+        );
+        testResults =
+          (yield this.editorStore.graphManagerState.graphManager.runTests(
+            [input],
+            this.editorStore.graphManagerState.graph,
+          )) as TestResult[];
+      }
       this.handleNewResults(testResults);
     } catch (error) {
       assertErrorThrown(error);

package/src/stores/editor/editor-state/element-editor-state/mapping/testable/MappingTestingHelper.ts

@@ -45,6 +45,7 @@ import {
   PropertyGraphFetchTree,
   PropertyExplicitReference,
   type ObserverContext,
+  Database,
 } from '@finos/legend-graph';
 import {
   buildGetAllFunction,
@@ -61,6 +62,7 @@ import {
 import {
   assertErrorThrown,
   assertTrue,
+  filterByType,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
 import type { DSL_Data_LegendStudioApplicationPlugin_Extension } from '../../../../../extensions/DSL_Data_LegendStudioApplicationPlugin_Extension.js';
@@ -103,6 +105,27 @@ export const createStoreBareModelStoreData = (
   return testData;
 };
 
+export const isRelationalStoreTestData = (val: StoreTestData): boolean =>
+  val.store.value instanceof Database;
+
+export const isRelationalMappingTest = (val: MappingTest): boolean => {
+  if (!val.storeTestData.length) {
+    return false;
+  }
+  return val.storeTestData.some((e) => isRelationalStoreTestData(e));
+};
+
+export const isRelationalMappingTestSuite = (
+  val: MappingTestSuite,
+): boolean => {
+  if (!val.tests.length) {
+    return false;
+  }
+  return val.tests
+    .filter(filterByType(MappingTest))
+    .some((e) => isRelationalMappingTest(e));
+};
+
 export const generateStoreTestDataFromSetImpl = (
   setImpl: SetImplementation,
   editorStore: EditorStore,