@finos/legend-graph 29.0.2 → 29.0.4

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

@@ -302,10 +302,14 @@ import {
 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_TEMPORARY__SnowflakeServiceDeploymentInput } from './engine/service/V1_TEMPORARY__SnowflakeServiceDeploymentInput.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';
+import type { FunctionActivator } from '../../../../graph/metamodel/pure/packageableElements/function/FunctionActivator.js';
+import { FunctionActivatorConfiguration } from '../../../action/functionActivator/FunctionActivatorConfiguration.js';
+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';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -315,6 +319,7 @@ class V1_PureModelContextDataIndex {
   classes: V1_Class[] = [];
   enumerations: V1_Enumeration[] = [];
   functions: V1_ConcreteFunctionDefinition[] = [];
+  functionActivators: V1_FunctionActivator[] = [];
   profiles: V1_Profile[] = [];
   measures: V1_Measure[] = [];
 
@@ -383,6 +388,8 @@ export const V1_indexPureModelContextData = (
       index.enumerations.push(el);
     } else if (el instanceof V1_ConcreteFunctionDefinition) {
       index.functions.push(el);
+    } else if (el instanceof V1_FunctionActivator) {
+      index.functionActivators.push(el);
     } else if (el instanceof V1_Profile) {
       index.profiles.push(el);
     } else if (el instanceof V1_Measure) {
@@ -448,6 +455,9 @@ export const V1_indexPureModelContextData = (
     (report.elementCount.enumeration ?? 0) + index.enumerations.length;
   report.elementCount.function =
     (report.elementCount.function ?? 0) + index.functions.length;
+  report.elementCount.functionActivators =
+    (report.elementCount.functionActivators ?? 0) +
+    index.functionActivators.length;
   report.elementCount.profile =
     (report.elementCount.profile ?? 0) + index.profiles.length;
   report.elementCount.measure =
@@ -1050,6 +1060,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_CONNECTIONS_AND_RUNTIMES__SUCCESS,
     );
 
+    // build function activators
+    graphBuilderState.setMessage(`Building function activators...`);
+    await this.buildFunctionActivators(graph, inputs, options);
+    stopWatch.record(
+      GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_DOMAIN_MODELS__SUCCESS,
+    );
+
     // build services
     graphBuilderState.setMessage(
       `Building services and execution environments...`,
@@ -1302,6 +1319,25 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  private async buildFunctionActivators(
+    graph: PureModel,
+    inputs: V1_PureGraphBuilderInput[],
+    options?: GraphBuilderOptions,
+  ): Promise<void> {
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.functionActivators.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
   private async buildStores(
     graph: PureModel,
     inputs: V1_PureGraphBuilderInput[],
@@ -2296,6 +2332,23 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   // --------------------------------------------- Execution ---------------------------------------------
 
+  private prepareExecutionContextGraphData(
+    graphData: GraphData,
+  ): V1_PureModelContext {
+    if (graphData instanceof InMemoryGraphData) {
+      return this.buildExecutionInputGraphData(graphData.graph);
+    } else if (graphData instanceof GraphDataWithOrigin) {
+      return this.buildPureModelSDLCPointer(
+        graphData.origin,
+        V1_PureGraphManager.PROD_PROTOCOL_VERSION,
+      );
+    }
+    throw new UnsupportedOperationError(
+      `Can't build Pure model context from unsupported graph data`,
+      graphData,
+    );
+  }
+
   public createExecutionInput = (
     graph: PureModel,
     mapping: Mapping | undefined,
@@ -2378,6 +2431,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         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 ||
@@ -2663,175 +2717,487 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  // --------------------------------------------- Service ---------------------------------------------
+  // --------------------------------------------- Query ---------------------------------------------
 
-  async registerService(
-    service: Service,
-    graph: PureModel,
-    groupId: string,
-    artifactId: string,
-    version: string | undefined,
-    server: string,
-    executionMode: ServiceExecutionMode,
-    options?: ServiceRegistrationOptions,
-  ): Promise<ServiceRegistrationSuccess> {
-    const serverServiceInfo = await this.engine.getServerServiceInfo();
-    // input
-    let input: V1_PureModelContext;
-    const protocol = new V1_Protocol(
-      V1_PureGraphManager.PURE_PROTOCOL_NAME,
-      serverServiceInfo.services.dependencies.pure,
+  async searchQueries(
+    searchSpecification: QuerySearchSpecification,
+  ): Promise<LightQuery[]> {
+    return (
+      await this.engine.searchQueries(
+        V1_transformQuerySearchSpecification(searchSpecification),
+      )
+    ).map((protocol) =>
+      V1_buildLightQuery(protocol, this.engine.getCurrentUserId()),
     );
-    switch (executionMode) {
-      case ServiceExecutionMode.FULL_INTERACTIVE: {
-        const data = this.createServiceRegistrationInputGraphData(graph);
-        data.elements.push(this.elementToProtocol<V1_Service>(service));
-        data.origin = new V1_PureModelContextPointer(protocol);
-        input = data;
-        break;
-      }
-      case ServiceExecutionMode.SEMI_INTERACTIVE: {
-        const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
-        const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
+  }
 
-        // data
-        const data = new V1_PureModelContextData();
-        data.origin = new V1_PureModelContextPointer(protocol);
-        const serviceProtocol = this.elementToProtocol<V1_Service>(service);
+  async getQueries(queryIds: string[]): Promise<LightQuery[]> {
+    return (await this.engine.getQueries(queryIds)).map((protocol) =>
+      V1_buildLightQuery(protocol, this.engine.getCurrentUserId()),
+    );
+  }
 
-        // override the URL pattern if specified
-        if (options?.TEMPORARY__semiInteractiveOverridePattern) {
-          serviceProtocol.pattern =
-            options.TEMPORARY__semiInteractiveOverridePattern;
-        }
+  async getLightQuery(queryId: string): Promise<LightQuery> {
+    return V1_buildLightQuery(
+      await this.engine.getQuery(queryId),
+      this.engine.getCurrentUserId(),
+    );
+  }
 
-        data.elements = [serviceProtocol];
+  async getQuery(queryId: string, graph: PureModel): Promise<Query> {
+    return V1_buildQuery(
+      await this.engine.getQuery(queryId),
+      graph,
+      this.engine.getCurrentUserId(),
+    );
+  }
 
-        // SDLC info
-        // TODO: We may need to add `runtime` pointers if the runtime defned in the service is a packageable runtime
-        // and not embedded.
-        const execution = service.execution;
-        if (execution instanceof PureSingleExecution) {
-          if (execution.mapping) {
-            sdlcInfo.packageableElementPointers = [
-              new V1_PackageableElementPointer(
-                PackageableElementPointerType.MAPPING,
-                execution.mapping.value.path,
-              ),
-            ];
-          }
-        } else if (execution instanceof PureMultiExecution) {
-          sdlcInfo.packageableElementPointers =
-            execution.executionParameters.map(
-              (e) =>
-                new V1_PackageableElementPointer(
-                  PackageableElementPointerType.MAPPING,
-                  e.mapping.value.path,
-                ),
-            );
-        } else {
-          throw new UnsupportedOperationError(
-            `Can't register service with the specified execution`,
-            execution,
-          );
-        }
-        // composite input
-        input = new V1_PureModelContextComposite(protocol, data, pointer);
-        break;
-      }
-      case ServiceExecutionMode.PROD: {
-        const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
-        const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
-        sdlcInfo.packageableElementPointers = [
-          new V1_PackageableElementPointer(
-            PackageableElementPointerType.SERVICE,
-            service.path,
-          ),
-        ];
-        input = pointer;
-        break;
-      }
-      default: {
-        throw new UnsupportedOperationError(
-          `Can't register service with execution mode '${executionMode}'`,
-        );
-      }
-    }
-    return V1_buildServiceRegistrationSuccess(
-      service,
-      await this.engine.registerService(
-        input,
-        server,
-        executionMode,
-        Boolean(options?.TEMPORARY__useStoreModel),
-        Boolean(options?.TEMPORARY__useGenerateLineage),
-      ),
+  async getQueryInfo(queryId: string): Promise<QueryInfo> {
+    const query = await this.engine.getQuery(queryId);
+    return {
+      name: query.name,
+      id: query.id,
+      versionId: query.versionId,
+      groupId: query.groupId,
+      artifactId: query.artifactId,
+      mapping: query.mapping,
+      runtime: query.runtime,
+      content: query.content,
+    };
+  }
+
+  async createQuery(query: Query, graph: PureModel): Promise<Query> {
+    return V1_buildQuery(
+      await this.engine.createQuery(V1_transformQuery(query)),
+      graph,
+      this.engine.getCurrentUserId(),
     );
   }
 
-  async bulkServiceRegistration(
-    services: Service[],
-    graph: PureModel,
-    groupId: string,
-    artifactId: string,
-    version: string | undefined,
-    server: string,
-    executionMode: ServiceExecutionMode,
-    options?: ServiceRegistrationOptions,
-  ): Promise<ServiceRegistrationResult[]> {
-    const serverServiceInfo = await this.engine.getServerServiceInfo();
-    const input: ServiceRegistrationInput[] = [];
+  async updateQuery(query: Query, graph: PureModel): Promise<Query> {
+    return V1_buildQuery(
+      await this.engine.updateQuery(V1_transformQuery(query)),
+      graph,
+      this.engine.getCurrentUserId(),
+    );
+  }
 
-    const protocol = new V1_Protocol(
-      V1_PureGraphManager.PURE_PROTOCOL_NAME,
-      serverServiceInfo.services.dependencies.pure,
+  async renameQuery(queryId: string, queryName: string): Promise<LightQuery> {
+    const query = await this.engine.getQuery(queryId);
+    query.name = queryName;
+    return V1_buildLightQuery(
+      await this.engine.updateQuery(query),
+      this.engine.getCurrentUserId(),
     );
-    switch (executionMode) {
-      case ServiceExecutionMode.FULL_INTERACTIVE: {
-        const pmcp = this.createBulkServiceRegistrationInput(graph, services);
-        pmcp.forEach((data) => {
-          const pmcd = data.context as V1_PureModelContextData;
-          pmcd.origin = new V1_PureModelContextPointer(protocol);
-          input.push({ service: data.service, context: pmcd });
-        });
-        break;
-      }
-      case ServiceExecutionMode.SEMI_INTERACTIVE: {
-        services.forEach((service) => {
-          const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
-          const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
-          // data
-          const data = new V1_PureModelContextData();
-          data.origin = new V1_PureModelContextPointer(protocol);
-          const serviceProtocol = this.elementToProtocol<V1_Service>(service);
+  }
 
-          // override the URL pattern if specified
-          if (options?.TEMPORARY__semiInteractiveOverridePattern) {
-            serviceProtocol.pattern =
-              options.TEMPORARY__semiInteractiveOverridePattern;
-          }
+  async deleteQuery(queryId: string): Promise<LightQuery> {
+    return V1_buildLightQuery(
+      await this.engine.deleteQuery(queryId),
+      this.engine.getCurrentUserId(),
+    );
+  }
 
-          data.elements = [serviceProtocol];
+  // --------------------------------------------- Analysis ---------------------------------------------
 
-          // SDLC info
-          // TODO: We may need to add `runtime` pointers if the runtime defned in the service is a packageable runtime
-          // and not embedded.
-          const execution = service.execution;
-          if (execution instanceof PureSingleExecution) {
-            if (execution.mapping) {
-              sdlcInfo.packageableElementPointers = [
-                new V1_PackageableElementPointer(
-                  PackageableElementPointerType.MAPPING,
-                  execution.mapping.value.path,
-                ),
-              ];
-            }
-          } else if (execution instanceof PureMultiExecution) {
-            sdlcInfo.packageableElementPointers =
-              execution.executionParameters.map(
-                (e) =>
-                  new V1_PackageableElementPointer(
-                    PackageableElementPointerType.MAPPING,
+  async analyzeMappingModelCoverage(
+    mapping: Mapping,
+    graph: PureModel,
+  ): Promise<MappingModelCoverageAnalysisResult> {
+    const input = new V1_MappingModelCoverageAnalysisInput();
+    input.clientVersion = V1_PureGraphManager.DEV_PROTOCOL_VERSION;
+    input.mapping = mapping.path;
+    input.model = graph.origin
+      ? this.buildPureModelSDLCPointer(graph.origin, undefined)
+      : this.buildExecutionInputGraphData(graph);
+    return V1_buildModelCoverageAnalysisResult(
+      await this.engine.analyzeMappingModelCoverage(input),
+      mapping,
+    );
+  }
+
+  buildMappingModelCoverageAnalysisResult(
+    input: RawMappingModelCoverageAnalysisResult,
+    mapping: Mapping,
+  ): MappingModelCoverageAnalysisResult {
+    return V1_buildModelCoverageAnalysisResult(
+      deserialize(
+        V1_MappingModelCoverageAnalysisResult,
+        input as PlainObject<V1_MappingModelCoverageAnalysisResult>,
+      ),
+      mapping,
+    );
+  }
+
+  generateStoreEntitlementAnalysisInput(
+    mapping: string,
+    runtime: string,
+    query: RawLambda | undefined,
+    graphData: GraphData,
+  ): V1_StoreEntitlementAnalysisInput {
+    const input = new V1_StoreEntitlementAnalysisInput();
+    input.clientVersion = V1_PureGraphManager.PROD_PROTOCOL_VERSION;
+    input.mapping = mapping;
+    input.runtime = runtime;
+    input.query = query
+      ? V1_transformRawLambda(
+          query,
+          new V1_GraphTransformerContextBuilder(
+            this.pluginManager.getPureProtocolProcessorPlugins(),
+          ).build(),
+        )
+      : undefined;
+    input.model = this.prepareExecutionContextGraphData(graphData);
+    return input;
+  }
+
+  async surveyDatasets(
+    mapping: string,
+    runtime: string,
+    query: RawLambda | undefined,
+    graphData: GraphData,
+  ): Promise<DatasetSpecification[]> {
+    return (
+      await this.engine.surveyDatasets(
+        this.generateStoreEntitlementAnalysisInput(
+          mapping,
+          runtime,
+          query,
+          graphData,
+        ),
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      )
+    ).map((dataset) =>
+      V1_buildDatasetSpecification(
+        dataset,
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ),
+    );
+  }
+
+  async checkDatasetEntitlements(
+    datasets: DatasetSpecification[],
+    mapping: string,
+    runtime: string,
+    query: RawLambda | undefined,
+    graphData: GraphData,
+  ): Promise<DatasetEntitlementReport[]> {
+    const input = new V1_EntitlementReportAnalyticsInput();
+    input.storeEntitlementAnalyticsInput =
+      this.generateStoreEntitlementAnalysisInput(
+        mapping,
+        runtime,
+        query,
+        graphData,
+      );
+    input.reports = datasets.map((dataset) =>
+      V1_transformDatasetSpecification(
+        dataset,
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ),
+    );
+    return (
+      await this.engine.checkDatasetEntitlements(
+        input,
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      )
+    ).map((report) =>
+      V1_buildDatasetEntitlementReport(
+        report,
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ),
+    );
+  }
+
+  async buildDatabase(input: DatabaseBuilderInput): Promise<Entity[]> {
+    const dbBuilderInput = new V1_DatabaseBuilderInput();
+    dbBuilderInput.connection = V1_transformRelationalDatabaseConnection(
+      input.connection,
+      new V1_GraphTransformerContextBuilder(
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ).build(),
+    );
+    const targetDatabase = new V1_TargetDatabase();
+    targetDatabase.package = input.targetDatabase.package;
+    targetDatabase.name = input.targetDatabase.name;
+    dbBuilderInput.targetDatabase = targetDatabase;
+    const config = new V1_DatabaseBuilderConfig();
+    config.maxTables = input.config.maxTables;
+    config.enrichTables = input.config.enrichTables;
+    config.enrichPrimaryKeys = input.config.enrichPrimaryKeys;
+    config.enrichColumns = input.config.enrichColumns;
+    config.patterns = input.config.patterns.map(
+      (storePattern: DatabasePattern): V1_DatabasePattern => {
+        const pattern = new V1_DatabasePattern();
+        pattern.schemaPattern = storePattern.schemaPattern;
+        pattern.tablePattern = storePattern.tablePattern;
+        pattern.escapeSchemaPattern = storePattern.escapeSchemaPattern;
+        pattern.escapeTablePattern = storePattern.escapeTablePattern;
+        return pattern;
+      },
+    );
+    dbBuilderInput.config = config;
+    return this.pureModelContextDataToEntities(
+      await this.engine.buildDatabase(dbBuilderInput),
+    );
+  }
+
+  // --------------------------------------------- Function ---------------------------------------------
+
+  async getAvailableFunctionActivatorConfigurations(
+    coreModel: CoreModel,
+    systemModel: SystemModel,
+  ): Promise<FunctionActivatorConfiguration[]> {
+    return (
+      await Promise.all(
+        (
+          await this.engine.getAvailableFunctionActivators()
+        ).map(async (info) => {
+          try {
+            const config = new FunctionActivatorConfiguration();
+            config.name = info.name;
+            config.description = info.description;
+            config.packageableElementJSONType =
+              info.configuration.packageableElementJSONType;
+
+            // build the mini graph for configuration
+            const graph = new PureModel(
+              coreModel,
+              systemModel,
+              this.pluginManager.getPureGraphPlugins(),
+            );
+            const _report = createGraphBuilderReport();
+            const _stopWatch = new StopWatch();
+            const _buildState = ActionState.create();
+            const data = new V1_PureModelContextData();
+            data.elements = info.configuration.model;
+            const buildInputs: V1_PureGraphBuilderInput[] = [
+              {
+                model: graph,
+                data: V1_indexPureModelContextData(
+                  _report,
+                  data,
+                  this.graphBuilderExtensions,
+                ),
+              },
+            ];
+            await this.buildGraphFromInputs(
+              graph,
+              buildInputs,
+              _report,
+              _stopWatch,
+              _buildState,
+              {},
+            );
+            config.graph = graph;
+            config.configurationType = graph.getClass(
+              info.configuration.topElement,
+            );
+            return config;
+          } catch (error) {
+            assertErrorThrown(error);
+            this.logService.warn(
+              LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
+              `Can't build function activator config: ${error.message}`,
+            );
+            return undefined;
+          }
+        }),
+      )
+    ).filter(isNonNullable);
+  }
+
+  async validateFunctionActivator(
+    functionActivator: FunctionActivator,
+    graphData: GraphData,
+  ): Promise<void> {
+    const input = new V1_FunctionActivatorInput();
+    input.clientVersion = V1_PureGraphManager.PROD_PROTOCOL_VERSION;
+    input.functionActivator = functionActivator.path;
+    input.model = this.prepareExecutionContextGraphData(graphData);
+    await this.engine.validateFunctionActivator(input);
+  }
+
+  async publishFunctionActivatorToSandbox(
+    functionActivator: FunctionActivator,
+    graphData: GraphData,
+  ): Promise<void> {
+    const input = new V1_FunctionActivatorInput();
+    input.clientVersion = V1_PureGraphManager.PROD_PROTOCOL_VERSION;
+    input.functionActivator = functionActivator.path;
+    input.model = this.prepareExecutionContextGraphData(graphData);
+    await this.engine.publishFunctionActivatorToSandbox(input);
+  }
+
+  // --------------------------------------------- Service ---------------------------------------------
+
+  async registerService(
+    service: Service,
+    graph: PureModel,
+    groupId: string,
+    artifactId: string,
+    version: string | undefined,
+    server: string,
+    executionMode: ServiceExecutionMode,
+    options?: ServiceRegistrationOptions,
+  ): Promise<ServiceRegistrationSuccess> {
+    const serverServiceInfo = await this.engine.getServerServiceInfo();
+    // input
+    let input: V1_PureModelContext;
+    const protocol = new V1_Protocol(
+      V1_PureGraphManager.PURE_PROTOCOL_NAME,
+      serverServiceInfo.services.dependencies.pure,
+    );
+    switch (executionMode) {
+      case ServiceExecutionMode.FULL_INTERACTIVE: {
+        const data = this.createServiceRegistrationInputGraphData(graph);
+        data.elements.push(this.elementToProtocol<V1_Service>(service));
+        data.origin = new V1_PureModelContextPointer(protocol);
+        input = data;
+        break;
+      }
+      case ServiceExecutionMode.SEMI_INTERACTIVE: {
+        const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
+        const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
+
+        // data
+        const data = new V1_PureModelContextData();
+        data.origin = new V1_PureModelContextPointer(protocol);
+        const serviceProtocol = this.elementToProtocol<V1_Service>(service);
+
+        // override the URL pattern if specified
+        if (options?.TEMPORARY__semiInteractiveOverridePattern) {
+          serviceProtocol.pattern =
+            options.TEMPORARY__semiInteractiveOverridePattern;
+        }
+
+        data.elements = [serviceProtocol];
+
+        // SDLC info
+        // TODO: We may need to add `runtime` pointers if the runtime defned in the service is a packageable runtime
+        // and not embedded.
+        const execution = service.execution;
+        if (execution instanceof PureSingleExecution) {
+          if (execution.mapping) {
+            sdlcInfo.packageableElementPointers = [
+              new V1_PackageableElementPointer(
+                PackageableElementPointerType.MAPPING,
+                execution.mapping.value.path,
+              ),
+            ];
+          }
+        } else if (execution instanceof PureMultiExecution) {
+          sdlcInfo.packageableElementPointers =
+            execution.executionParameters.map(
+              (e) =>
+                new V1_PackageableElementPointer(
+                  PackageableElementPointerType.MAPPING,
+                  e.mapping.value.path,
+                ),
+            );
+        } else {
+          throw new UnsupportedOperationError(
+            `Can't register service with the specified execution`,
+            execution,
+          );
+        }
+        // composite input
+        input = new V1_PureModelContextComposite(protocol, data, pointer);
+        break;
+      }
+      case ServiceExecutionMode.PROD: {
+        const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
+        const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
+        sdlcInfo.packageableElementPointers = [
+          new V1_PackageableElementPointer(
+            PackageableElementPointerType.SERVICE,
+            service.path,
+          ),
+        ];
+        input = pointer;
+        break;
+      }
+      default: {
+        throw new UnsupportedOperationError(
+          `Can't register service with execution mode '${executionMode}'`,
+        );
+      }
+    }
+    return V1_buildServiceRegistrationSuccess(
+      service,
+      await this.engine.registerService(
+        input,
+        server,
+        executionMode,
+        Boolean(options?.TEMPORARY__useStoreModel),
+        Boolean(options?.TEMPORARY__useGenerateLineage),
+      ),
+    );
+  }
+
+  async bulkServiceRegistration(
+    services: Service[],
+    graph: PureModel,
+    groupId: string,
+    artifactId: string,
+    version: string | undefined,
+    server: string,
+    executionMode: ServiceExecutionMode,
+    options?: ServiceRegistrationOptions,
+  ): Promise<ServiceRegistrationResult[]> {
+    const serverServiceInfo = await this.engine.getServerServiceInfo();
+    const input: ServiceRegistrationInput[] = [];
+
+    const protocol = new V1_Protocol(
+      V1_PureGraphManager.PURE_PROTOCOL_NAME,
+      serverServiceInfo.services.dependencies.pure,
+    );
+    switch (executionMode) {
+      case ServiceExecutionMode.FULL_INTERACTIVE: {
+        const pmcp = this.createBulkServiceRegistrationInput(graph, services);
+        pmcp.forEach((data) => {
+          const pmcd = data.context as V1_PureModelContextData;
+          pmcd.origin = new V1_PureModelContextPointer(protocol);
+          input.push({ service: data.service, context: pmcd });
+        });
+        break;
+      }
+      case ServiceExecutionMode.SEMI_INTERACTIVE: {
+        services.forEach((service) => {
+          const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
+          const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
+          // data
+          const data = new V1_PureModelContextData();
+          data.origin = new V1_PureModelContextPointer(protocol);
+          const serviceProtocol = this.elementToProtocol<V1_Service>(service);
+
+          // override the URL pattern if specified
+          if (options?.TEMPORARY__semiInteractiveOverridePattern) {
+            serviceProtocol.pattern =
+              options.TEMPORARY__semiInteractiveOverridePattern;
+          }
+
+          data.elements = [serviceProtocol];
+
+          // SDLC info
+          // TODO: We may need to add `runtime` pointers if the runtime defned in the service is a packageable runtime
+          // and not embedded.
+          const execution = service.execution;
+          if (execution instanceof PureSingleExecution) {
+            if (execution.mapping) {
+              sdlcInfo.packageableElementPointers = [
+                new V1_PackageableElementPointer(
+                  PackageableElementPointerType.MAPPING,
+                  execution.mapping.value.path,
+                ),
+              ];
+            }
+          } else if (execution instanceof PureMultiExecution) {
+            sdlcInfo.packageableElementPointers =
+              execution.executionParameters.map(
+                (e) =>
+                  new V1_PackageableElementPointer(
+                    PackageableElementPointerType.MAPPING,
                     e.mapping.value.path,
                   ),
               );
@@ -2954,111 +3320,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     });
     return results;
   };
-  async TEMPORARY__deploySnowflakeService(
-    query: RawLambda,
-    graph: PureModel,
-  ): Promise<PlainObject> {
-    const input = new V1_TEMPORARY__SnowflakeServiceDeploymentInput();
-    input.clientVersion = V1_PureGraphManager.PROD_PROTOCOL_VERSION;
-    input.query = V1_transformRawLambda(
-      query,
-      new V1_GraphTransformerContextBuilder(
-        this.pluginManager.getPureProtocolProcessorPlugins(),
-      ).build(),
-    );
-    input.model = graph.origin
-      ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-      : this.buildExecutionInputGraphData(graph);
-    return this.engine
-      .getEngineServerClient()
-      .TEMPORARY__deploySnowflakeService(
-        V1_TEMPORARY__SnowflakeServiceDeploymentInput.serialization.toJson(
-          input,
-        ),
-      );
-  }
-  // -----------------------------/Applications/Visual Studio Code.app/Contents/Resources/app/out/vs/code/electron-sandbox/workbench/workbench.html---------------- Query ---------------------------------------------
-
-  async searchQueries(
-    searchSpecification: QuerySearchSpecification,
-  ): Promise<LightQuery[]> {
-    return (
-      await this.engine.searchQueries(
-        V1_transformQuerySearchSpecification(searchSpecification),
-      )
-    ).map((protocol) =>
-      V1_buildLightQuery(protocol, this.engine.getCurrentUserId()),
-    );
-  }
-
-  async getQueries(queryIds: string[]): Promise<LightQuery[]> {
-    return (await this.engine.getQueries(queryIds)).map((protocol) =>
-      V1_buildLightQuery(protocol, this.engine.getCurrentUserId()),
-    );
-  }
-
-  async getLightQuery(queryId: string): Promise<LightQuery> {
-    return V1_buildLightQuery(
-      await this.engine.getQuery(queryId),
-      this.engine.getCurrentUserId(),
-    );
-  }
-
-  // --------------------------------------------- Query ------------------------------------------------------
-
-  async getQuery(queryId: string, graph: PureModel): Promise<Query> {
-    return V1_buildQuery(
-      await this.engine.getQuery(queryId),
-      graph,
-      this.engine.getCurrentUserId(),
-    );
-  }
-
-  async getQueryInfo(queryId: string): Promise<QueryInfo> {
-    const query = await this.engine.getQuery(queryId);
-    return {
-      name: query.name,
-      id: query.id,
-      versionId: query.versionId,
-      groupId: query.groupId,
-      artifactId: query.artifactId,
-      mapping: query.mapping,
-      runtime: query.runtime,
-      content: query.content,
-    };
-  }
-
-  async createQuery(query: Query, graph: PureModel): Promise<Query> {
-    return V1_buildQuery(
-      await this.engine.createQuery(V1_transformQuery(query)),
-      graph,
-      this.engine.getCurrentUserId(),
-    );
-  }
-
-  async updateQuery(query: Query, graph: PureModel): Promise<Query> {
-    return V1_buildQuery(
-      await this.engine.updateQuery(V1_transformQuery(query)),
-      graph,
-      this.engine.getCurrentUserId(),
-    );
-  }
-
-  async renameQuery(queryId: string, queryName: string): Promise<LightQuery> {
-    const query = await this.engine.getQuery(queryId);
-    query.name = queryName;
-    return V1_buildLightQuery(
-      await this.engine.updateQuery(query),
-      this.engine.getCurrentUserId(),
-    );
-  }
-
-  async deleteQuery(queryId: string): Promise<LightQuery> {
-    return V1_buildLightQuery(
-      await this.engine.deleteQuery(queryId),
-      this.engine.getCurrentUserId(),
-    );
-  }
 
   async cancelUserExecutions(broadcastToCluster: boolean): Promise<string> {
     return this.engine.cancelUserExecutions(broadcastToCluster);
@@ -3108,164 +3369,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return hashMap;
   }
 
-  async analyzeMappingModelCoverage(
-    mapping: Mapping,
-    graph: PureModel,
-  ): Promise<MappingModelCoverageAnalysisResult> {
-    const input = new V1_MappingModelCoverageAnalysisInput();
-    input.clientVersion = V1_PureGraphManager.DEV_PROTOCOL_VERSION;
-    input.mapping = mapping.path;
-    input.model = graph.origin
-      ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-      : this.buildExecutionInputGraphData(graph);
-    return V1_buildModelCoverageAnalysisResult(
-      await this.engine.analyzeMappingModelCoverage(input),
-      mapping,
-    );
-  }
-
-  buildMappingModelCoverageAnalysisResult(
-    input: RawMappingModelCoverageAnalysisResult,
-    mapping: Mapping,
-  ): MappingModelCoverageAnalysisResult {
-    return V1_buildModelCoverageAnalysisResult(
-      deserialize(
-        V1_MappingModelCoverageAnalysisResult,
-        input as PlainObject<V1_MappingModelCoverageAnalysisResult>,
-      ),
-      mapping,
-    );
-  }
-
-  generateStoreEntitlementAnalysisInput(
-    mapping: string,
-    runtime: string,
-    query: RawLambda | undefined,
-    graphData: GraphData,
-  ): V1_StoreEntitlementAnalysisInput {
-    const input = new V1_StoreEntitlementAnalysisInput();
-    input.clientVersion = V1_PureGraphManager.PROD_PROTOCOL_VERSION;
-    input.mapping = mapping;
-    input.runtime = runtime;
-    input.query = query
-      ? V1_transformRawLambda(
-          query,
-          new V1_GraphTransformerContextBuilder(
-            this.pluginManager.getPureProtocolProcessorPlugins(),
-          ).build(),
-        )
-      : undefined;
-
-    if (graphData instanceof InMemoryGraphData) {
-      input.model = this.buildExecutionInputGraphData(graphData.graph);
-    } else if (graphData instanceof GraphDataWithOrigin) {
-      input.model = this.buildPureModelSDLCPointer(
-        graphData.origin,
-        V1_PureGraphManager.PROD_PROTOCOL_VERSION,
-      );
-    } else {
-      throw new UnsupportedOperationError(
-        `Can't process unsupported graph data`,
-        graphData,
-      );
-    }
-    return input;
-  }
-
-  async surveyDatasets(
-    mapping: string,
-    runtime: string,
-    query: RawLambda | undefined,
-    graphData: GraphData,
-  ): Promise<DatasetSpecification[]> {
-    return (
-      await this.engine.surveyDatasets(
-        this.generateStoreEntitlementAnalysisInput(
-          mapping,
-          runtime,
-          query,
-          graphData,
-        ),
-        this.pluginManager.getPureProtocolProcessorPlugins(),
-      )
-    ).map((dataset) =>
-      V1_buildDatasetSpecification(
-        dataset,
-        this.pluginManager.getPureProtocolProcessorPlugins(),
-      ),
-    );
-  }
-
-  async checkDatasetEntitlements(
-    datasets: DatasetSpecification[],
-    mapping: string,
-    runtime: string,
-    query: RawLambda | undefined,
-    graphData: GraphData,
-  ): Promise<DatasetEntitlementReport[]> {
-    const input = new V1_EntitlementReportAnalyticsInput();
-    input.storeEntitlementAnalyticsInput =
-      this.generateStoreEntitlementAnalysisInput(
-        mapping,
-        runtime,
-        query,
-        graphData,
-      );
-    input.reports = datasets.map((dataset) =>
-      V1_transformDatasetSpecification(
-        dataset,
-        this.pluginManager.getPureProtocolProcessorPlugins(),
-      ),
-    );
-    return (
-      await this.engine.checkDatasetEntitlements(
-        input,
-        this.pluginManager.getPureProtocolProcessorPlugins(),
-      )
-    ).map((report) =>
-      V1_buildDatasetEntitlementReport(
-        report,
-        this.pluginManager.getPureProtocolProcessorPlugins(),
-      ),
-    );
-  }
-
-  // --------------------------------------------- Database ---------------------------------------------
-
-  async buildDatabase(input: DatabaseBuilderInput): Promise<Entity[]> {
-    const dbBuilderInput = new V1_DatabaseBuilderInput();
-    dbBuilderInput.connection = V1_transformRelationalDatabaseConnection(
-      input.connection,
-      new V1_GraphTransformerContextBuilder(
-        this.pluginManager.getPureProtocolProcessorPlugins(),
-      ).build(),
-    );
-    const targetDatabase = new V1_TargetDatabase();
-    targetDatabase.package = input.targetDatabase.package;
-    targetDatabase.name = input.targetDatabase.name;
-    dbBuilderInput.targetDatabase = targetDatabase;
-    const config = new V1_DatabaseBuilderConfig();
-    config.maxTables = input.config.maxTables;
-    config.enrichTables = input.config.enrichTables;
-    config.enrichPrimaryKeys = input.config.enrichPrimaryKeys;
-    config.enrichColumns = input.config.enrichColumns;
-    config.patterns = input.config.patterns.map(
-      (storePattern: DatabasePattern): V1_DatabasePattern => {
-        const pattern = new V1_DatabasePattern();
-        pattern.schemaPattern = storePattern.schemaPattern;
-        pattern.tablePattern = storePattern.tablePattern;
-        pattern.escapeSchemaPattern = storePattern.escapeSchemaPattern;
-        pattern.escapeTablePattern = storePattern.escapeTablePattern;
-        return pattern;
-      },
-    );
-    dbBuilderInput.config = config;
-    return this.pureModelContextDataToEntities(
-      await this.engine.buildDatabase(dbBuilderInput),
-    );
-  }
-
-  // --------------------------------------------- Utilities ---------------------------------------------
+  // --------------------------------------------- Shared ---------------------------------------------
 
   elementToEntity = (
     element: PackageableElement,
@@ -3282,8 +3386,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return entity;
   };
 
-  // --------------------------------------------- Shared ---------------------------------------------
-
   private prunePureModelContextData = (
     data: V1_PureModelContextData,
     elementFilter?: (val: V1_PackageableElement) => boolean,
@@ -3500,7 +3602,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   private getElementClassiferPath = (
     protocol: V1_PackageableElement,
   ): string => {
-    if (protocol instanceof V1_INTERNAL__UnknownPackageableElement) {
+    if (
+      protocol instanceof V1_INTERNAL__UnknownPackageableElement ||
+      protocol instanceof V1_INTERNAL__UnknownFunctionActivator
+    ) {
       const _type = protocol.content._type;
       const classifierPath = isString(_type)
         ? this.elementClassifierPathMap.get(_type)