@finos/legend-graph 28.1.8 → 29.0.0

package/src/graph-manager/action/changeDetection/STO_Relational_ObserverHelper.ts

@@ -129,6 +129,9 @@ import {
   observe_SetImplementation,
 } from './DSL_Mapping_ObserverHelper.js';
 import type { DEPRECATED__RelationalInputData } from '../../../graph/metamodel/pure/packageableElements/mapping/DEPRECATED__MappingTest.js';
+import { INTERNAL__UnknownPostProcessor } from '../../../graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/INTERNAL__UnknownPostProcessor.js';
+import { INTERNAL__UnknownDatasourceSpecification } from '../../../graph/metamodel/pure/packageableElements/store/relational/connection/INTERNAL__UnknownDatasourceSpecification.js';
+import { INTERNAL__UnknownAuthenticationStrategy } from '../../../graph/metamodel/pure/packageableElements/store/relational/connection/INTERNAL__UnknownAuthenticationStrategy.js';
 
 // ------------------------------------- Operation -------------------------------------
 
@@ -874,11 +877,23 @@ export const observe_TrinoDatasourceSpecification = skipObserved(
   },
 );
 
+const observe_INTERNAL__UnknownDatasourceSpecification = skipObserved(
+  (
+    metamodel: INTERNAL__UnknownDatasourceSpecification,
+  ): INTERNAL__UnknownDatasourceSpecification =>
+    makeObservable(metamodel, {
+      content: observable,
+      hashCode: computed,
+    }),
+);
+
 export const observe_DatasourceSpecification = (
   metamodel: DatasourceSpecification,
   context: ObserverContext,
 ): DatasourceSpecification => {
-  if (metamodel instanceof StaticDatasourceSpecification) {
+  if (metamodel instanceof INTERNAL__UnknownDatasourceSpecification) {
+    return observe_INTERNAL__UnknownDatasourceSpecification(metamodel);
+  } else if (metamodel instanceof StaticDatasourceSpecification) {
     return observe_StaticDatasourceSpecification(metamodel);
   } else if (metamodel instanceof DatabricksDatasourceSpecification) {
     return observe_DatabricksDatasourceSpecification(metamodel);
@@ -1017,11 +1032,23 @@ export const observe_TrinoDelegatedKerberosAuthenticationStrategy =
       }),
   );
 
+const observe_INTERNAL__UnknownAuthenticationStrategy = skipObserved(
+  (
+    metamodel: INTERNAL__UnknownAuthenticationStrategy,
+  ): INTERNAL__UnknownAuthenticationStrategy =>
+    makeObservable(metamodel, {
+      hashCode: computed,
+      content: observable,
+    }),
+);
+
 export const observe_AuthenticationStrategy = (
   metamodel: AuthenticationStrategy,
   context: ObserverContext,
 ): AuthenticationStrategy => {
-  if (metamodel instanceof DelegatedKerberosAuthenticationStrategy) {
+  if (metamodel instanceof INTERNAL__UnknownAuthenticationStrategy) {
+    return observe_INTERNAL__UnknownAuthenticationStrategy(metamodel);
+  } else if (metamodel instanceof DelegatedKerberosAuthenticationStrategy) {
     return observe_DelegatedKerberosAuthenticationStrategy(metamodel);
   } else if (metamodel instanceof DefaultH2AuthenticationStrategy) {
     return observe_DefaultH2AuthenticationStrategy(metamodel);
@@ -1128,11 +1155,25 @@ export const observe_MapperPostProcessor = (
   return metamodel;
 };
 
+const observe_INTERNAL__UnknownPostProcessor = (
+  metamodel: INTERNAL__UnknownPostProcessor,
+): INTERNAL__UnknownPostProcessor => {
+  observe_Abstract_PostProcessor(metamodel);
+
+  makeObservable(metamodel, {
+    content: observable,
+  });
+
+  return metamodel;
+};
+
 export const observe_PostProcessor = (
   metamodel: PostProcessor,
   context: ObserverContext,
 ): PostProcessor => {
-  if (metamodel instanceof MapperPostProcessor) {
+  if (metamodel instanceof INTERNAL__UnknownPostProcessor) {
+    return observe_INTERNAL__UnknownPostProcessor(metamodel);
+  } else if (metamodel instanceof MapperPostProcessor) {
     return observe_MapperPostProcessor(metamodel);
   }
   const extraObservers = context.plugins.flatMap(

package/src/graph-manager/action/compilation/CompilationResult.ts

@@ -16,6 +16,7 @@
 
 import type { Entity } from '@finos/legend-storage';
 import type { CompilationWarning } from './CompilationWarning.js';
+import type { SourceInformation } from '../SourceInformation.js';
 
 export interface CompilationResult {
   warnings: CompilationWarning[] | undefined;
@@ -23,4 +24,5 @@ export interface CompilationResult {
 
 export interface TextCompilationResult extends CompilationResult {
   entities: Entity[];
+  sourceInformationIndex: Map<string, SourceInformation>;
 }

package/src/graph-manager/action/execution/ExecutionResult.ts

@@ -138,12 +138,3 @@ export class ClassExecutionResult extends ExecutionResult {
   override builder = new ClassBuilder(BuilderType.CLASS_BUILDER);
   objects!: object;
 }
-
-export class INTERNAL__UnknownExecutionResult extends ExecutionResult {
-  content: object;
-
-  constructor(content: object) {
-    super();
-    this.content = content;
-  }
-}

package/src/graph-manager/action/execution/ExecutionResultHelper.ts

@@ -20,23 +20,23 @@ import {
   JsonExecutionResult,
   TDSExecutionResult,
   ClassExecutionResult,
-  INTERNAL__UnknownExecutionResult,
 } from './ExecutionResult.js';
+import { INTERNAL__UnknownExecutionResult } from './INTERNAL__UnknownExecutionResult.js';
 
 // Execution Results often wrap the result values with additional metadata.
 // This method extracts the actual values from the execution result
 export const extractExecutionResultValues = (
   executionResult: ExecutionResult,
 ): object => {
-  if (executionResult instanceof JsonExecutionResult) {
+  if (executionResult instanceof INTERNAL__UnknownExecutionResult) {
+    return executionResult.content;
+  } else if (executionResult instanceof JsonExecutionResult) {
     return executionResult.values;
   } else if (executionResult instanceof TDSExecutionResult) {
     // Note we need the result values in object format to run test results
     return executionResult.result.rows.map((v) => ({ values: v.values }));
   } else if (executionResult instanceof ClassExecutionResult) {
     return executionResult.objects;
-  } else if (executionResult instanceof INTERNAL__UnknownExecutionResult) {
-    return executionResult.content;
   }
   throw new UnsupportedOperationError(
     `Can't extract values from execution result`,

package/src/graph-manager/action/execution/INTERNAL__UnknownExecutionResult.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 type { PlainObject } from '@finos/legend-shared';
+import { ExecutionResult } from './ExecutionResult.js';
+
+export class INTERNAL__UnknownExecutionResult extends ExecutionResult {
+  content!: PlainObject;
+}

package/src/graph-manager/action/protocol/ClassifierPathMapping.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+export type ClassifierPathMapping = { type: string; classifierPath: string };

package/src/graph-manager/protocol/pure/extensions/DSL_Mapping_PureProtocolProcessorPlugin_Extension.ts

@@ -51,7 +51,7 @@ export type PropertyMappingTransformationExcludabilityChecker = (
 
 export type V1_ClassMappingSerializer = (
   value: V1_ClassMapping,
-) => V1_ClassMapping | undefined;
+) => PlainObject<V1_ClassMapping> | undefined;
 
 export type V1_ClassMappingDeserializer = (
   json: PlainObject<V1_ClassMapping>,

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

@@ -40,6 +40,7 @@ import {
   uniq,
   IllegalStateError,
   filterByType,
+  isString,
 } from '@finos/legend-shared';
 import type { TEMPORARY__AbstractEngineConfig } from '../../../../graph-manager/action/TEMPORARY__AbstractEngineConfig.js';
 import {
@@ -200,6 +201,7 @@ import {
   V1_buildGenerationOutput,
   V1_buildLightQuery,
   V1_transformQuerySearchSpecification,
+  V1_buildSourceInformation,
 } from './engine/V1_EngineHelper.js';
 import { V1_buildExecutionResult } from './engine/execution/V1_ExecutionHelper.js';
 import {
@@ -301,6 +303,9 @@ import type { DEPRECATED__MappingTest } from '../../../../graph/metamodel/pure/p
 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';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -320,15 +325,16 @@ class V1_PureModelContextDataIndex {
 
   sectionIndices: V1_SectionIndex[] = [];
 
-  services: V1_Service[] = [];
-
   fileGenerations: V1_FileGenerationSpecification[] = [];
   generationSpecifications: V1_GenerationSpecification[] = [];
 
   dataElements: V1_DataElement[] = [];
 
+  services: V1_Service[] = [];
   executionEnvironments: V1_ExecutionEnvironmentInstance[] = [];
 
+  INTERNAL__unknownElements: V1_INTERNAL__UnknownPackageableElement[] = [];
+
   otherElementsByBuilder: Map<
     V1_ElementBuilder<V1_PackageableElement>,
     V1_PackageableElement[]
@@ -367,7 +373,9 @@ export const V1_indexPureModelContextData = (
   >();
   data.elements.forEach((el) => {
     let isIndexedAsOtherElement = false;
-    if (el instanceof V1_Association) {
+    if (el instanceof V1_INTERNAL__UnknownPackageableElement) {
+      index.INTERNAL__unknownElements.push(el);
+    } else if (el instanceof V1_Association) {
       index.associations.push(el);
     } else if (el instanceof V1_Class) {
       index.classes.push(el);
@@ -412,6 +420,7 @@ export const V1_indexPureModelContextData = (
       index.nativeElements.push(el);
     }
   });
+
   otherElementsByClass.forEach((elements, _class) => {
     const builder = extensions.getExtraBuilderForProtocolClassOrThrow(_class);
     index.otherElementsByBuilder.set(
@@ -444,6 +453,9 @@ export const V1_indexPureModelContextData = (
   report.elementCount.measure =
     (report.elementCount.measure ?? 0) + index.measures.length;
 
+  report.elementCount.dataElement =
+    (report.elementCount.dataElement ?? 0) + index.dataElements.length;
+
   report.elementCount.store =
     (report.elementCount.store ?? 0) + index.stores.length;
   report.elementCount.mapping =
@@ -455,6 +467,12 @@ export const V1_indexPureModelContextData = (
 
   report.elementCount.service =
     (report.elementCount.service ?? 0) + index.services.length;
+  report.elementCount.executionEnvironment =
+    (report.elementCount.executionEnvironment ?? 0) +
+    index.executionEnvironments.length;
+
+  report.elementCount.unknown =
+    (report.elementCount.unknown ?? 0) + index.INTERNAL__unknownElements.length;
 
   return index;
 };
@@ -480,6 +498,8 @@ interface ServiceRegistrationInput {
 }
 
 export class V1_PureGraphManager extends AbstractPureGraphManager {
+  private readonly elementClassifierPathMap = new Map<string, string>();
+
   // Pure Client Version represent the version of the pure protocol.
   // Most Engine APIs will interrupt an undefined pure client version to mean
   // use the latest production version of the protocol i.e V20_0_0, while version
@@ -536,6 +556,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       .getEngineServerClient()
       .setTracerService(options?.tracerService ?? new TracerService());
     await this.engine.setup(config);
+
+    const classifierPathMapEntries =
+      config.TEMPORARY__classifierPathMapping ??
+      (await this.engine.getClassifierPathMapping());
+    classifierPathMapEntries.forEach((entry) => {
+      this.elementClassifierPathMap.set(entry.type, entry.classifierPath);
+    });
   }
 
   getSupportedProtocolVersion(): string {
@@ -1614,11 +1641,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   // --------------------------------------------- Grammar ---------------------------------------------
 
-  async graphToPureCode(graph: PureModel): Promise<string> {
+  async graphToPureCode(
+    graph: PureModel,
+    options?: { pretty?: boolean | undefined },
+  ): Promise<string> {
     const startTime = Date.now();
     const graphData = this.graphToPureModelContextData(graph);
     const grammarToJson = await this.engine.pureModelContextDataToPureCode(
       graphData,
+      Boolean(options?.pretty),
     );
     this.logService.info(
       LogEvent.create(
@@ -1634,10 +1665,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return this.engine.prettyLambdaContent(lambda);
   }
 
-  async entitiesToPureCode(entities: Entity[]): Promise<string> {
+  async entitiesToPureCode(
+    entities: Entity[],
+    options?: { pretty?: boolean | undefined },
+  ): Promise<string> {
     const startTime = Date.now();
     const grammarToJson = await this.engine.pureModelContextDataToPureCode(
       await this.entitiesToPureModelContextData(entities),
+      Boolean(options?.pretty),
     );
     this.logService.info(
       LogEvent.create(
@@ -1652,15 +1687,29 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   async pureCodeToEntities(
     code: string,
     options?: {
+      sourceInformationIndex?: Map<string, SourceInformation>;
       TEMPORARY__keepSectionIndex?: boolean;
     },
   ): Promise<Entity[]> {
-    const pmcd = await this.engine.pureCodeToPureModelContextData(code);
+    const index = new Map<string, V1_SourceInformation>();
+    const pmcd = await this.engine.pureCodeToPureModelContextData(code, {
+      sourceInformationIndex: options?.sourceInformationIndex
+        ? index
+        : undefined,
+    });
+    const sourceInformationIndex = options?.sourceInformationIndex;
+    if (sourceInformationIndex) {
+      sourceInformationIndex.clear();
+      for (const [key, value] of index.entries()) {
+        sourceInformationIndex.set(key, value);
+      }
+    }
     pmcd.elements = pmcd.elements.filter(
       (el) =>
         options?.TEMPORARY__keepSectionIndex ??
         !(el instanceof V1_SectionIndex),
     );
+
     return this.pureModelContextDataToEntities(pmcd);
   }
 
@@ -1787,6 +1836,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const entities = this.pureModelContextDataToEntities(
       compilationResult.model,
     );
+    const sourceInformationIndex = new Map<string, SourceInformation>();
+    compilationResult.sourceInformationIndex.forEach((value, key) => {
+      sourceInformationIndex.set(key, V1_buildSourceInformation(value));
+    });
 
     report.timings = {
       ...report.timings,
@@ -1800,6 +1853,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         (warning) =>
           new CompilationWarning(warning.message, warning.sourceInformation),
       ),
+      sourceInformationIndex,
     };
   }
 
@@ -3006,6 +3060,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  async cancelUserExecutions(broadcastToCluster: boolean): Promise<string> {
+    return this.engine.cancelUserExecutions(broadcastToCluster);
+  }
+
   // --------------------------------------------- Change Detection ---------------------------------------------
 
   async buildHashesIndex(entities: Entity[]): Promise<Map<string, string>> {
@@ -3442,7 +3500,18 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   private getElementClassiferPath = (
     protocol: V1_PackageableElement,
   ): string => {
-    if (protocol instanceof V1_Association) {
+    if (protocol instanceof V1_INTERNAL__UnknownPackageableElement) {
+      const _type = protocol.content._type;
+      const classifierPath = isString(_type)
+        ? this.elementClassifierPathMap.get(_type)
+        : undefined;
+      if (classifierPath) {
+        return classifierPath;
+      }
+      throw new UnsupportedOperationError(
+        `Can't get classifier path for element '${protocol.path}': no classifier path mapping available`,
+      );
+    } else if (protocol instanceof V1_Association) {
       return CORE_PURE_PATH.ASSOCIATION;
     } else if (protocol instanceof V1_Class) {
       return CORE_PURE_PATH.CLASS;

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

@@ -27,6 +27,7 @@ import {
   returnUndefOnError,
   deserializeMap,
   StopWatch,
+  guaranteeNonNullable,
 } from '@finos/legend-shared';
 import type { RawLambda } from '../../../../../graph/metamodel/pure/rawValueSpecification/RawLambda.js';
 import {
@@ -71,10 +72,7 @@ import {
   V1_TestDataGenerationExecutionInput,
 } from './execution/V1_ExecuteInput.js';
 import type { V1_ExecutionPlan } from '../model/executionPlan/V1_ExecutionPlan.js';
-import {
-  type V1_ExecutionResult,
-  V1_serializeExecutionResult,
-} from './execution/V1_ExecutionResult.js';
+import { type V1_ExecutionResult } from './execution/V1_ExecutionResult.js';
 import { V1_ServiceStorage } from './service/V1_ServiceStorage.js';
 import { V1_ServiceRegistrationResult } from './service/V1_ServiceRegistrationResult.js';
 import type { V1_PureModelContext } from '../model/context/V1_PureModelContext.js';
@@ -111,6 +109,11 @@ import {
   type V1_EntitlementReportAnalyticsInput,
   V1_entitlementReportAnalyticsInputModelSchema,
 } from './analytics/V1_StoreEntitlementAnalysis.js';
+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';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -212,27 +215,73 @@ export class V1_Engine {
     }
   }
 
+  // ------------------------------------------- Protocol -------------------------------------------
+
+  async getClassifierPathMapping(): Promise<ClassifierPathMapping[]> {
+    try {
+      return await this.engineServerClient.getClassifierPathMap();
+    } catch {
+      return [];
+    }
+  }
+
   // ------------------------------------------- Grammar -------------------------------------------
 
+  private extractElementSourceInformationIndexFromPureModelContextDataJSON(
+    json: PlainObject<V1_PureModelContextData>,
+  ): Map<string, V1_SourceInformation> {
+    const sourceInformationIndex = new Map<string, V1_SourceInformation>();
+    const elements = json.elements;
+    if (Array.isArray(elements)) {
+      elements.forEach((elementJson) => {
+        const element =
+          returnUndefOnError(() =>
+            V1_INTERNAL__PackageableElementWithSourceInformation.serialization.fromJson(
+              elementJson,
+            ),
+          ) ?? undefined;
+        if (element?.sourceInformation) {
+          sourceInformationIndex.set(
+            `${element.package}${ELEMENT_PATH_DELIMITER}${element.name}`,
+            element.sourceInformation,
+          );
+        }
+      });
+    }
+    return sourceInformationIndex;
+  }
+
   pureModelContextDataToPureCode(
     graph: V1_PureModelContextData,
+    pretty: boolean,
   ): Promise<string> {
     return this.engineServerClient.JSONToGrammar_model(
       this.serializePureModelContext(graph),
-      V1_RenderStyle.STANDARD,
+      pretty ? V1_RenderStyle.PRETTY : V1_RenderStyle.STANDARD,
     );
   }
 
   async pureCodeToPureModelContextData(
     code: string,
-    options?: { onError?: () => void },
+    options?: {
+      sourceInformationIndex?: Map<string, V1_SourceInformation> | undefined;
+      onError?: () => void;
+    },
   ): Promise<V1_PureModelContextData> {
-    return V1_deserializePureModelContextData(
-      await this.pureCodeToPureModelContextDataJSON(code, {
-        ...options,
-        returnSourceInformation: false,
-      }),
-    );
+    const json = await this.pureCodeToPureModelContextDataJSON(code, {
+      ...options,
+      returnSourceInformation: Boolean(options?.sourceInformationIndex),
+    });
+    const sourceInformationIndex = options?.sourceInformationIndex;
+    if (sourceInformationIndex) {
+      sourceInformationIndex.clear();
+      this.extractElementSourceInformationIndexFromPureModelContextDataJSON(
+        json,
+      ).forEach((value, key) => {
+        sourceInformationIndex.set(key, value);
+      });
+    }
+    return V1_deserializePureModelContextData(json);
   }
 
   private async pureCodeToPureModelContextDataJSON(
@@ -434,8 +483,7 @@ export class V1_Engine {
   ): Promise<V1_TextCompilationResult> {
     const mainGraph = await this.pureCodeToPureModelContextDataJSON(graphText, {
       ...options,
-      // NOTE: we need to return source information here so we can locate the compilation
-      // errors/warnings
+      // NOTE: we need to return source information here so we can locate the compilation errors/warnings
       returnSourceInformation: true,
     });
     const pureModelContextDataJson = compileContext
@@ -464,6 +512,10 @@ export class V1_Engine {
         )?.map((warning) =>
           V1_CompilationWarning.serialization.fromJson(warning),
         ),
+        sourceInformationIndex:
+          this.extractElementSourceInformationIndexFromPureModelContextDataJSON(
+            mainGraph,
+          ),
       };
     } catch (error) {
       assertErrorThrown(error);
@@ -614,7 +666,7 @@ export class V1_Engine {
     // from the front end to engine would take up a lot of bandwidth.
     const textModel = new V1_PureModelContextText();
     textModel.serializer = model.serializer;
-    textModel.code = await this.pureModelContextDataToPureCode(model);
+    textModel.code = await this.pureModelContextDataToPureCode(model, false);
     return (
       await this.engineServerClient.generateFile(
         generationMode,
@@ -755,6 +807,13 @@ export class V1_Engine {
     );
   }
 
+  async cancelUserExecutions(broadcastToCluster: boolean): Promise<string> {
+    return this.engineServerClient.cancelUserExecutions(
+      guaranteeNonNullable(this.getCurrentUserId()),
+      broadcastToCluster,
+    );
+  }
+
   // ------------------------------------------ Analysis ------------------------------------------
 
   async analyzeMappingModelCoverage(

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

@@ -372,7 +372,7 @@ export const V1_buildGenerationConfigurationDescription = (
   return metamodel;
 };
 
-const buildSourceInformation = (
+export const V1_buildSourceInformation = (
   sourceInformation: V1_SourceInformation,
 ): SourceInformation =>
   new SourceInformation(
@@ -403,7 +403,7 @@ export const V1_buildCompilationError = (
 ): CompilationError => {
   const metamodel = new CompilationError(protocol.message);
   metamodel.sourceInformation = protocol.sourceInformation
-    ? buildSourceInformation(protocol.sourceInformation)
+    ? V1_buildSourceInformation(protocol.sourceInformation)
     : undefined;
   return metamodel;
 };
@@ -411,7 +411,7 @@ export const V1_buildCompilationError = (
 export const V1_buildParserError = (protocol: V1_ParserError): ParserError => {
   const metamodel = new ParserError(protocol.message);
   metamodel.sourceInformation = protocol.sourceInformation
-    ? buildSourceInformation(protocol.sourceInformation)
+    ? V1_buildSourceInformation(protocol.sourceInformation)
     : undefined;
   return metamodel;
 };

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

@@ -64,6 +64,7 @@ import type {
 } from './analytics/V1_StoreEntitlementAnalysis.js';
 import type { V1_RunTestsResult } from './test/V1_RunTestsResult.js';
 import type { V1_TEMPORARY__SnowflakeServiceDeploymentInput } from './service/V1_TEMPORARY__SnowflakeServiceDeploymentInput.js';
+import type { ClassifierPathMapping } from '../../../../action/protocol/ClassifierPathMapping.js';
 
 enum CORE_ENGINE_ACTIVITY_TRACE {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -91,6 +92,8 @@ enum CORE_ENGINE_ACTIVITY_TRACE {
   UPDATE_QUERY = 'update query',
   DELETE_QUERY = 'delete query',
 
+  CANCEL_USER_EXECUTIONS = 'cancel user executions',
+
   MAPPING_MODEL_COVERAGE_ANALYTICS = 'mapping model coverage analytics',
   SURVEY_DATASET_ANALYTICS = 'survey dataset analytics',
   STORE_ENTITLEMENT_ANALYTICS = 'store entitlement analytics',
@@ -158,9 +161,15 @@ export class V1_EngineServerClient extends AbstractServerClient {
   // ------------------------------------------- Server -------------------------------------------
 
   _server = (): string => `${this.baseUrl}/server/v1`;
+  _executionManager = (): string => `${this._server()}/executionManager`;
   getCurrentUserId = (): Promise<string> =>
     this.get(`${this._server()}/currentUser`);
 
+  // ------------------------------------------- Protocol -------------------------------------------
+
+  getClassifierPathMap = (): Promise<ClassifierPathMapping[]> =>
+    this.get(`${this._pure()}/protocol/pure/getClassifierPathMap`);
+
   // ------------------------------------------- Grammar -------------------------------------------
 
   _grammarToJSON = (): string => `${this._pure()}/grammar/grammarToJson`;
@@ -693,4 +702,18 @@ export class V1_EngineServerClient extends AbstractServerClient {
       input,
       undefined,
     );
+
+  cancelUserExecutions = (
+    userID: string,
+    broadcastToCluster: boolean,
+  ): Promise<string> =>
+    this.postWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.CANCEL_USER_EXECUTIONS),
+      `${this._executionManager()}/cancelUserExecution`,
+      {},
+      {},
+      { [HttpHeader.ACCEPT]: ContentType.TEXT_PLAIN },
+      { userID, broadcastToCluster },
+      { enableCompression: true },
+    );
 }

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { V1_SourceInformation } from '../../model/V1_SourceInformation.js';
 import type { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData.js';
 import type { V1_CompilationWarning } from './V1_CompilationWarning.js';
 
@@ -23,4 +24,5 @@ export interface V1_CompilationResult {
 
 export interface V1_TextCompilationResult extends V1_CompilationResult {
   model: V1_PureModelContextData;
+  sourceInformationIndex: Map<string, V1_SourceInformation>;
 }