@finos/legend-graph 29.0.5 → 30.0.0

package/src/graph-manager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -37,7 +37,6 @@ import {
   addUniqueEntry,
   uuid,
   deleteEntry,
-  uniq,
   IllegalStateError,
   filterByType,
   isString,
@@ -158,7 +157,6 @@ import {
   V1_DatabaseBuilderConfig,
   V1_DatabaseBuilderInput,
   V1_DatabasePattern,
-  V1_setupDatabaseBuilderInputSerialization,
   V1_TargetDatabase,
 } from './engine/generation/V1_DatabaseBuilderInput.js';
 import { V1_transformRelationalDatabaseConnection } from './transformation/pureGraph/from/V1_ConnectionTransformer.js';
@@ -301,7 +299,6 @@ import {
 } from '../../../GraphData.js';
 import type { DEPRECATED__MappingTest } from '../../../../graph/metamodel/pure/packageableElements/mapping/DEPRECATED__MappingTest.js';
 import { DEPRECATED__validate_MappingTest } from '../../../action/validation/DSL_Mapping_ValidationHelper.js';
-import { V1_SERVICE_ELEMENT_PROTOCOL_TYPE } from './transformation/pureProtocol/serializationHelpers/V1_ServiceSerializationHelper.js';
 import { V1_INTERNAL__UnknownPackageableElement } from './model/packageableElements/V1_INTERNAL__UnknownPackageableElement.js';
 import type { SourceInformation } from '../../../action/SourceInformation.js';
 import type { V1_SourceInformation } from './model/V1_SourceInformation.js';
@@ -310,6 +307,10 @@ import { FunctionActivatorConfiguration } from '../../../action/functionActivato
 import { V1_FunctionActivatorInput } from './engine/functionActivator/V1_FunctionActivatorInput.js';
 import { V1_FunctionActivator } from './model/packageableElements/function/V1_FunctionActivator.js';
 import { V1_INTERNAL__UnknownFunctionActivator } from './model/packageableElements/function/V1_INTERNAL__UnknownFunctionActivator.js';
+import type { RelationalDatabaseConnection } from '../../../../STO_Relational_Exports.js';
+import { V1_RawSQLExecuteInput } from './engine/execution/V1_RawSQLExecuteInput.js';
+import type { SubtypeInfo } from '../../../action/protocol/ProtocolInfo.js';
+import { V1_INTERNAL__UnknownStore } from './model/packageableElements/store/V1_INTERNAL__UnknownStore.js';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -355,10 +356,12 @@ const mergePureModelContextData = (
   const mergedData = new V1_PureModelContextData();
   for (const _data of data) {
     mergedData.elements = mergedData.elements.concat(_data.elements);
-    mergedData.INTERNAL__rawDependencyEntities =
-      mergedData.INTERNAL__rawDependencyEntities.concat(
-        _data.INTERNAL__rawDependencyEntities,
-      );
+    const rawDependencyEntities = (
+      mergedData.INTERNAL__rawDependencyEntities ?? []
+    ).concat(_data.INTERNAL__rawDependencyEntities ?? []);
+    mergedData.INTERNAL__rawDependencyEntities = rawDependencyEntities.length
+      ? rawDependencyEntities
+      : undefined;
     mergedData.serializer = _data.serializer ?? mergedData.serializer;
     mergedData.origin = _data.origin ?? mergedData.origin;
   }
@@ -509,6 +512,10 @@ interface ServiceRegistrationInput {
 
 export class V1_PureGraphManager extends AbstractPureGraphManager {
   private readonly elementClassifierPathMap = new Map<string, string>();
+  private readonly subtypeInfo: SubtypeInfo = {
+    storeSubtypes: [],
+    functionActivatorSubtypes: [],
+  };
 
   // Pure Client Version represent the version of the pure protocol.
   // Most Engine APIs will interrupt an undefined pure client version to mean
@@ -532,10 +539,33 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     this.graphBuilderExtensions = new V1_GraphBuilderExtensions(
       this.pluginManager.getPureProtocolProcessorPlugins(),
     );
+  }
+
+  TEMPORARY__getEngineConfig(): TEMPORARY__AbstractEngineConfig {
+    return this.engine.config;
+  }
+
+  async initialize(
+    config: TEMPORARY__EngineSetupConfig,
+    options?: {
+      tracerService?: TracerService | undefined;
+    },
+  ): Promise<void> {
+    this.engine = new V1_Engine(config.clientConfig, this.logService);
+    this.engine
+      .getEngineServerClient()
+      .setTracerService(options?.tracerService ?? new TracerService());
+
+    await Promise.all([
+      this.engine.setup(config),
+      this.configureElementClassifierPathMap(config),
+      this.configureSubtypeInfoMap(config),
+    ]);
 
     // setup serialization plugins
     V1_setupPureModelContextDataSerialization(
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
     );
     V1_setupDatabaseSerialization(
       this.pluginManager.getPureProtocolProcessorPlugins(),
@@ -546,27 +576,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     V1_setupLegacyRuntimeSerialization(
       this.pluginManager.getPureProtocolProcessorPlugins(),
     );
-    V1_setupDatabaseBuilderInputSerialization(
-      this.pluginManager.getPureProtocolProcessorPlugins(),
-    );
   }
 
-  TEMPORARY__getEngineConfig(): TEMPORARY__AbstractEngineConfig {
-    return this.engine.config;
-  }
-
-  async initialize(
+  private async configureElementClassifierPathMap(
     config: TEMPORARY__EngineSetupConfig,
-    options?: {
-      tracerService?: TracerService | undefined;
-    },
   ): Promise<void> {
-    this.engine = new V1_Engine(config.clientConfig, this.logService);
-    this.engine
-      .getEngineServerClient()
-      .setTracerService(options?.tracerService ?? new TracerService());
-    await this.engine.setup(config);
-
     const classifierPathMapEntries =
       config.TEMPORARY__classifierPathMapping ??
       (await this.engine.getClassifierPathMapping());
@@ -575,6 +589,18 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     });
   }
 
+  private async configureSubtypeInfoMap(
+    config: TEMPORARY__EngineSetupConfig,
+  ): Promise<void> {
+    const subtypeInfo =
+      config.TEMPORARY__subtypeInfo ?? (await this.engine.getSubtypeInfo());
+    this.subtypeInfo.storeSubtypes = subtypeInfo.storeSubtypes;
+    this.subtypeInfo.functionActivatorSubtypes =
+      subtypeInfo.functionActivatorSubtypes;
+  }
+
+  // --------------------------------------------- Generic ---------------------------------------------
+
   getSupportedProtocolVersion(): string {
     return PureClientVersion.V1_0_0;
   }
@@ -703,6 +729,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
               entitiesWithOrigin.entities,
               projectModelData,
               this.pluginManager.getPureProtocolProcessorPlugins(),
+              this.subtypeInfo,
             );
           },
         ),
@@ -781,6 +808,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         entities,
         data,
         this.pluginManager.getPureProtocolProcessorPlugins(),
+        this.subtypeInfo,
       );
       stopWatch.record(
         GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS,
@@ -866,6 +894,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         entities,
         data,
         this.pluginManager.getPureProtocolProcessorPlugins(),
+        this.subtypeInfo,
       );
       stopWatch.record(
         GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS,
@@ -957,6 +986,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
               entities,
               generatedData,
               this.pluginManager.getPureProtocolProcessorPlugins(),
+              this.subtypeInfo,
             );
           },
         ),
@@ -2336,7 +2366,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     graphData: GraphData,
   ): V1_PureModelContext {
     if (graphData instanceof InMemoryGraphData) {
-      return this.buildExecutionInputGraphData(graphData.graph);
+      return this.getFullGraphModelData(graphData.graph);
     } else if (graphData instanceof GraphDataWithOrigin) {
       return this.buildPureModelSDLCPointer(
         graphData.origin,
@@ -2360,7 +2390,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     this.createExecutionInputWithPureModelContext(
       graph.origin
         ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-        : this.buildExecutionInputGraphData(graph),
+        : this.getFullGraphModelData(graph),
       mapping,
       lambda,
       runtime,
@@ -2406,52 +2436,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return executeInput;
   };
 
-  private buildExecutionInputGraphData(
-    graph: PureModel,
-  ): V1_PureModelContextData {
-    /**
-     * NOTE: to lessen network load, we might need to think of a way to only include relevant part of the pure model context data here
-     *
-     * Graph data models can be classified based on dependency hieararchy:
-     * 1. Building blocks: models that all other models depend on: e.g. domain models, connections, etc.
-     * 2. Consumers: models that depends on other models: e.g. mapping, service, etc.
-     * 3. Unrelated: models that depends on nothing and vice versa: e.g. text
-     *
-     * It would be great if we can provide a way to walk the mapping to select only relevant part, but the problem is we cannot really walk the lambda
-     * object to identify relevant classes yet. so the more economical way to to base on the classification above and the knowledge about hierarchy between
-     * models (e.g. service can use mapping, runtime, connection, store, etc.) we can roughly prune the graph model data by group. Following is an example
-     * for mapping used for execution, but this can generalized if we introduce hierarchy/ranking for model type
-     */
-    const graphData = this.getFullGraphModelData(graph);
-    const prunedGraphData = this.prunePureModelContextData(
-      graphData,
-      (element) =>
-        element instanceof V1_Class ||
-        element instanceof V1_Enumeration ||
-        element instanceof V1_Profile ||
-        element instanceof V1_Association ||
-        element instanceof V1_ConcreteFunctionDefinition ||
-        element instanceof V1_FunctionActivator ||
-        element instanceof V1_Measure ||
-        element instanceof V1_Store ||
-        element instanceof V1_PackageableConnection ||
-        element instanceof V1_PackageableRuntime ||
-        element instanceof V1_Mapping,
-      undefined,
-    );
-    const extraExecutionElements = this.pluginManager
-      .getPureProtocolProcessorPlugins()
-      .flatMap(
-        (element) => element.V1_getExtraExecutionInputCollectors?.() ?? [],
-      )
-      .flatMap((getter) => getter(graph, graphData));
-    prunedGraphData.elements = uniq([
-      ...prunedGraphData.elements,
-      ...extraExecutionElements,
-    ]);
-    return prunedGraphData;
-  }
-
   async runQuery(
     lambda: RawLambda,
     mapping: Mapping,
@@ -2504,7 +2488,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const stopWatch = new StopWatch();
     const pureModelContext = graph.origin
       ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-      : this.buildExecutionInputGraphData(graph);
+      : this.getFullGraphModelData(graph);
     stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
     await Promise.all(
       tests.map((t) =>
@@ -2649,7 +2633,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     this.createExecutionInputWithPureModelContext(
       graph.origin
         ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-        : this.buildExecutionInputGraphData(graph),
+        : this.getFullGraphModelData(graph),
       mapping,
       lambda,
       runtime,
@@ -2811,7 +2795,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     input.mapping = mapping.path;
     input.model = graph.origin
       ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-      : this.buildExecutionInputGraphData(graph);
+      : this.getFullGraphModelData(graph);
     return V1_buildModelCoverageAnalysisResult(
       await this.engine.analyzeMappingModelCoverage(input),
       mapping,
@@ -2940,7 +2924,28 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
     dbBuilderInput.config = config;
     return this.pureModelContextDataToEntities(
-      await this.engine.buildDatabase(dbBuilderInput),
+      await this.engine.buildDatabase(
+        dbBuilderInput,
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ),
+    );
+  }
+
+  override async executeRawSQL(
+    connection: RelationalDatabaseConnection,
+    sql: string,
+  ): Promise<string> {
+    const input = new V1_RawSQLExecuteInput();
+    input.connection = V1_transformRelationalDatabaseConnection(
+      connection,
+      new V1_GraphTransformerContextBuilder(
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ).build(),
+    );
+    input.sql = sql;
+    return this.engine.executeRawSQL(
+      input,
+      this.pluginManager.getPureProtocolProcessorPlugins(),
     );
   }
 
@@ -3052,8 +3057,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
     switch (executionMode) {
       case ServiceExecutionMode.FULL_INTERACTIVE: {
-        const data = this.createServiceRegistrationInputGraphData(graph);
-        data.elements.push(this.elementToProtocol<V1_Service>(service));
+        const data = this.TEMPORARY__prepareGraphDataForServiceRegistration(
+          this.getFullGraphModelData(graph),
+          this.elementToProtocol<V1_Service>(service),
+        );
         data.origin = new V1_PureModelContextPointer(protocol);
         input = data;
         break;
@@ -3282,28 +3289,25 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  // NOTE: We almost should never be poking into dependency entities. However for service registration the input
-  // expects only one service in the graph data. Perhaps, the service registration API should be modified to accept
-  // service as a parameter outside the model
-  private pruneServicesFromGraphForRegistration = (
+  // NOTE: This is somewhat hacky: service registration the input expects only the first service in the graph data
+  // to be the service used for registration.
+  // TODO: the service registration API should be modified to accept service as a parameter outside the model
+  private TEMPORARY__prepareGraphDataForServiceRegistration = (
     graphData: V1_PureModelContextData,
-  ): V1_PureModelContextData =>
-    this.prunePureModelContextData(
-      graphData,
-      (element: V1_PackageableElement) => !(element instanceof V1_Service),
-      (entity: Entity) => {
-        const content = entity.content as { _type: string };
-        return content._type !== V1_SERVICE_ELEMENT_PROTOCOL_TYPE;
-      },
-    );
-
-  private createServiceRegistrationInputGraphData = (
-    graph: PureModel,
+    service: V1_Service,
   ): V1_PureModelContextData => {
-    const graphData = this.getFullGraphModelData(graph);
-    const prunedGraphData =
-      this.pruneServicesFromGraphForRegistration(graphData);
-    return prunedGraphData;
+    graphData.elements = graphData.elements.filter(
+      (element) => element.path !== service.path,
+    );
+    // insert the service as the first element so it gets indexed first
+    graphData.elements.unshift(service);
+    if (graphData.INTERNAL__rawDependencyEntities) {
+      graphData.INTERNAL__rawDependencyEntities =
+        graphData.INTERNAL__rawDependencyEntities.filter(
+          (entity) => entity.path !== service.path,
+        );
+    }
+    return graphData;
   };
 
   private createBulkServiceRegistrationInput = (
@@ -3313,12 +3317,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const graphData = this.getFullGraphModelData(graph);
     const results: ServiceRegistrationInput[] = [];
     services.forEach((service) => {
-      const prunedGraphData =
-        this.pruneServicesFromGraphForRegistration(graphData);
-      prunedGraphData.elements.push(
-        this.elementToProtocol<V1_Service>(service),
-      );
-      results.push({ service: service, context: prunedGraphData });
+      results.push({
+        service: service,
+        context: this.TEMPORARY__prepareGraphDataForServiceRegistration(
+          graphData,
+          this.elementToProtocol<V1_Service>(service),
+        ),
+      });
     });
     return results;
   };
@@ -3352,6 +3357,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       entities,
       pureModelContextData,
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
       TEMPORARY__entityPathIndex,
     );
     await Promise.all(
@@ -3388,22 +3394,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return entity;
   };
 
-  private prunePureModelContextData = (
-    data: V1_PureModelContextData,
-    elementFilter?: (val: V1_PackageableElement) => boolean,
-    entityFilter?: (entity: Entity) => boolean,
-  ): V1_PureModelContextData => {
-    const prunedGraphData = new V1_PureModelContextData();
-    prunedGraphData.elements = data.elements.filter((element) =>
-      elementFilter ? elementFilter(element) : true,
-    );
-    prunedGraphData.INTERNAL__rawDependencyEntities =
-      data.INTERNAL__rawDependencyEntities.filter((entity) =>
-        entityFilter ? entityFilter(entity) : true,
-      );
-    return prunedGraphData;
-  };
-
   private buildPureModelSDLCPointer(
     origin: GraphDataOrigin,
     clientVersion: string | undefined,
@@ -3461,6 +3451,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ),
       data,
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
     );
     const mainGraphBuilderInput: V1_PureGraphBuilderInput[] = [
       {
@@ -3498,6 +3489,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
               ),
             projectModelData,
             this.pluginManager.getPureProtocolProcessorPlugins(),
+            this.subtypeInfo,
           );
         },
       ),
@@ -3547,10 +3539,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       ...contextData1.elements,
       ...contextData2.elements,
     ];
-    contextData1.INTERNAL__rawDependencyEntities = [
-      ...contextData1.INTERNAL__rawDependencyEntities,
-      ...contextData2.INTERNAL__rawDependencyEntities,
+    const rawDependencyEntities = [
+      ...(contextData1.INTERNAL__rawDependencyEntities ?? []),
+      ...(contextData2.INTERNAL__rawDependencyEntities ?? []),
     ];
+    contextData1.INTERNAL__rawDependencyEntities = rawDependencyEntities.length
+      ? rawDependencyEntities
+      : undefined;
     return contextData1;
   }
 
@@ -3580,6 +3575,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       entities,
       graphData,
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
     );
     return graphData;
   }
@@ -3606,7 +3602,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   ): string => {
     if (
       protocol instanceof V1_INTERNAL__UnknownPackageableElement ||
-      protocol instanceof V1_INTERNAL__UnknownFunctionActivator
+      protocol instanceof V1_INTERNAL__UnknownFunctionActivator ||
+      protocol instanceof V1_INTERNAL__UnknownStore
     ) {
       const _type = protocol.content._type;
       const classifierPath = isString(_type)

package/src/graph-manager/protocol/pure/v1/engine/V1_Engine.ts

@@ -65,7 +65,10 @@ import {
   V1_buildParserError,
 } from './V1_EngineHelper.js';
 import { V1_LightQuery, V1_Query } from './query/V1_Query.js';
-import { V1_DatabaseBuilderInput } from './generation/V1_DatabaseBuilderInput.js';
+import {
+  type V1_DatabaseBuilderInput,
+  V1_serializeDatabaseBuilderInput,
+} from './generation/V1_DatabaseBuilderInput.js';
 import type { V1_ServiceConfigurationInfo } from './service/V1_ServiceConfiguration.js';
 import {
   V1_ExecuteInput,
@@ -113,10 +116,17 @@ import type { V1_SourceInformation } from '../model/V1_SourceInformation.js';
 import { V1_INTERNAL__PackageableElementWithSourceInformation } from '../transformation/pureProtocol/serializationHelpers/V1_CoreSerializationHelper.js';
 import { ELEMENT_PATH_DELIMITER } from '../../../../../graph/MetaModelConst.js';
 import { V1_serializeExecutionResult } from './execution/V1_ExecutionHelper.js';
-import type { ClassifierPathMapping } from '../../../../action/protocol/ClassifierPathMapping.js';
+import type {
+  ClassifierPathMapping,
+  SubtypeInfo,
+} from '../../../../action/protocol/ProtocolInfo.js';
 import { V1_FunctionActivatorInfo } from './functionActivator/V1_FunctionActivatorInfo.js';
 import { V1_FunctionActivatorError } from './functionActivator/V1_FunctionActivatorError.js';
 import { V1_FunctionActivatorInput } from './functionActivator/V1_FunctionActivatorInput.js';
+import {
+  V1_serializeRawSQLExecuteInput,
+  type V1_RawSQLExecuteInput,
+} from './execution/V1_RawSQLExecuteInput.js';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -228,6 +238,24 @@ export class V1_Engine {
     }
   }
 
+  async getSubtypeInfo(): Promise<SubtypeInfo> {
+    try {
+      return await this.engineServerClient.getSubtypeInfo();
+    } catch {
+      // NOTE: this is temporary until we have this API functional and released
+      // See https://github.com/finos/legend-engine/pull/1858
+      return {
+        functionActivatorSubtypes: ['snowflakeApp'],
+        storeSubtypes: [
+          'MongoDatabase',
+          'serviceStore',
+          'relational',
+          'binding',
+        ],
+      };
+    }
+  }
+
   // ------------------------------------------- Grammar -------------------------------------------
 
   private extractElementSourceInformationIndexFromPureModelContextDataJSON(
@@ -859,14 +887,24 @@ export class V1_Engine {
 
   async buildDatabase(
     input: V1_DatabaseBuilderInput,
+    plugins: PureProtocolProcessorPlugin[],
   ): Promise<V1_PureModelContextData> {
     return V1_deserializePureModelContextData(
       await this.engineServerClient.buildDatabase(
-        serialize(V1_DatabaseBuilderInput, input),
+        V1_serializeDatabaseBuilderInput(input, plugins),
       ),
     );
   }
 
+  async executeRawSQL(
+    input: V1_RawSQLExecuteInput,
+    plugins: PureProtocolProcessorPlugin[],
+  ): Promise<string> {
+    return this.engineServerClient.executeRawSQL(
+      V1_serializeRawSQLExecuteInput(input, plugins),
+    );
+  }
+
   // ------------------------------------------- Function -------------------------------------------
 
   async getAvailableFunctionActivators(): Promise<V1_FunctionActivatorInfo[]> {

package/src/graph-manager/protocol/pure/v1/engine/V1_EngineServerClient.ts

@@ -63,10 +63,15 @@ import type {
   V1_SurveyDatasetsResult,
 } from './analytics/V1_StoreEntitlementAnalysis.js';
 import type { V1_RunTestsResult } from './test/V1_RunTestsResult.js';
-import type { ClassifierPathMapping } from '../../../../action/protocol/ClassifierPathMapping.js';
+import type {
+  ClassifierPathMapping,
+  SubtypeInfo,
+} from '../../../../action/protocol/ProtocolInfo.js';
 import type { V1_FunctionActivatorInfo } from './functionActivator/V1_FunctionActivatorInfo.js';
 import type { V1_FunctionActivatorError } from './functionActivator/V1_FunctionActivatorError.js';
 import type { V1_FunctionActivatorInput } from './functionActivator/V1_FunctionActivatorInput.js';
+import type { V1_DatabaseBuilderInput } from './generation/V1_DatabaseBuilderInput.js';
+import type { V1_RawSQLExecuteInput } from './execution/V1_RawSQLExecuteInput.js';
 
 enum CORE_ENGINE_ACTIVITY_TRACE {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -99,6 +104,9 @@ enum CORE_ENGINE_ACTIVITY_TRACE {
   MAPPING_MODEL_COVERAGE_ANALYTICS = 'mapping model coverage analytics',
   SURVEY_DATASET_ANALYTICS = 'survey dataset analytics',
   STORE_ENTITLEMENT_ANALYTICS = 'store entitlement analytics',
+
+  DATABASE_SCHEMA_EXPLORATION = 'database schema exploration',
+  DATABASE_RAW_SQL_EXECUTION = 'database raw SQL execution',
 }
 
 type GrammarParserBatchInputEntry = {
@@ -165,6 +173,9 @@ export class V1_EngineServerClient extends AbstractServerClient {
   getClassifierPathMap = (): Promise<ClassifierPathMapping[]> =>
     this.get(`${this._pure()}/protocol/pure/getClassifierPathMap`);
 
+  getSubtypeInfo = (): Promise<SubtypeInfo> =>
+    this.get(`${this._pure()}/protocol/pure/getSubtypeInfo`);
+
   // ------------------------------------------- Grammar -------------------------------------------
 
   _grammarToJSON = (): string => `${this._pure()}/grammar/grammarToJson`;
@@ -622,15 +633,27 @@ export class V1_EngineServerClient extends AbstractServerClient {
     );
 
   _databaseUtilities = (): string => `${this._pure()}/utilities/database`;
+
   buildDatabase = (
-    input: PlainObject<V1_ExecuteInput>,
+    input: PlainObject<V1_DatabaseBuilderInput>,
   ): Promise<PlainObject<V1_PureModelContextData>> =>
     this.postWithTracing(
-      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.GENERATE_EXECUTION_PLAN),
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.DATABASE_SCHEMA_EXPLORATION),
       `${this._databaseUtilities()}/schemaExploration`,
       input,
     );
 
+  executeRawSQL = (
+    input: PlainObject<V1_RawSQLExecuteInput>,
+  ): Promise<string> =>
+    this.postWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.DATABASE_RAW_SQL_EXECUTION),
+      `${this._databaseUtilities()}/executeRawSQL`,
+      input,
+      {},
+      { [HttpHeader.ACCEPT]: ContentType.TEXT_PLAIN },
+    );
+
   // ------------------------------------------- Function ---------------------------------------
 
   _functionActivator = (): string => `${this.baseUrl}/functionActivator`;

package/src/graph-manager/protocol/pure/v1/engine/execution/V1_RawSQLExecuteInput.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 {
+  createModelSchema,
+  primitive,
+  custom,
+  serialize,
+  type ModelSchema,
+} from 'serializr';
+import { type PlainObject } from '@finos/legend-shared';
+import {
+  V1_serializeConnectionValue,
+  V1_deserializeConnectionValue,
+} from '../../transformation/pureProtocol/serializationHelpers/V1_ConnectionSerializationHelper.js';
+import type { V1_RelationalDatabaseConnection } from '../../model/packageableElements/store/relational/connection/V1_RelationalDatabaseConnection.js';
+import type { PureProtocolProcessorPlugin } from '../../../PureProtocolProcessorPlugin.js';
+
+export class V1_RawSQLExecuteInput {
+  connection!: V1_RelationalDatabaseConnection;
+  sql!: string;
+}
+
+const createRawSQLExecuteInpuModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_RawSQLExecuteInput> =>
+  createModelSchema(V1_RawSQLExecuteInput, {
+    connection: custom(
+      (val) => V1_serializeConnectionValue(val, false, plugins),
+      (val) => V1_deserializeConnectionValue(val, false, plugins),
+    ),
+    sql: primitive(),
+  });
+
+export const V1_serializeRawSQLExecuteInput = (
+  value: V1_RawSQLExecuteInput,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_RawSQLExecuteInput> =>
+  serialize(createRawSQLExecuteInpuModelSchema(plugins), value);