@finos/legend-graph 32.3.21 → 32.3.23

package/src/graph/metamodel/pure/dataProduct/DataProduct.ts

@@ -38,6 +38,8 @@ import type { Class } from '../packageableElements/domain/Class.js';
 import type { Enumeration } from '../packageableElements/domain/Enumeration.js';
 import type { Association } from '../packageableElements/domain/Association.js';
 import type { EmbeddedData } from '../data/EmbeddedData.js';
+import { ConcreteFunctionDefinition } from '../packageableElements/function/ConcreteFunctionDefinition.js';
+import { generateFunctionPrettyName } from '../../../helpers/PureLanguageHelper.js';
 
 export abstract class AccessPoint implements Hashable {
   id: string;
@@ -157,7 +159,7 @@ export class DataProductDiagram implements Hashable {
       CORE_HASH_STRUCTURE.DATA_PRODUCT_DIAGRAM,
       this.title,
       this.description ?? '',
-      this.diagram,
+      this.diagram.path,
     ]);
   }
 }
@@ -200,6 +202,90 @@ export class ModelAccessPointGroup
   }
 }
 
+export class NativeModelExecutionContext implements Hashable {
+  key!: string;
+  mapping!: PackageableElementReference<Mapping>;
+  runtime: PackageableElementReference<PackageableRuntime> | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_NATIVE_MODEL_EXECUTION_CONTEXT,
+      this.key,
+      this.mapping.valueForSerialization ?? '',
+      this.runtime?.valueForSerialization ?? '',
+    ]);
+  }
+}
+
+export class NativeModelAccess implements Hashable {
+  featuredElements: DataProductElementScope[] = [];
+  nativeModelExecutionContexts!: NativeModelExecutionContext[];
+  defaultExecutionContext!: string;
+  diagrams: DataProductDiagram[] = [];
+  sampleQueries: SampleQuery[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_NATIVE_MODEL_ACCESS,
+      hashArray(this.featuredElements),
+      hashArray(this.diagrams),
+      hashArray(this.nativeModelExecutionContexts),
+      this.defaultExecutionContext,
+      hashArray(this.sampleQueries),
+    ]);
+  }
+}
+
+export abstract class SampleQuery implements Hashable {
+  id!: string;
+  title!: string;
+  description: string | undefined;
+  executionContextKey!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_SAMPLE_QUERY,
+      this.id,
+      this.title,
+      this.description ?? '',
+      this.executionContextKey,
+    ]);
+  }
+}
+
+export class InLineSampleQuery extends SampleQuery implements Hashable {
+  query!: RawLambda;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_INLINE_SAMPLE_QUERY,
+      super.hashCode,
+      this.query,
+    ]);
+  }
+}
+
+export class PackageableElementSampleQuery
+  extends SampleQuery
+  implements Hashable
+{
+  query!: PackageableElementReference<PackageableElement>;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_PACKAGEABLE_ELEMENT_SAMPLE_QUERY,
+      super.hashCode,
+      this.query.value instanceof ConcreteFunctionDefinition
+        ? generateFunctionPrettyName(this.query.value, {
+            fullPath: true,
+            spacing: false,
+            notIncludeParamName: true,
+          })
+        : (this.query.valueForSerialization ?? ''),
+    ]);
+  }
+}
+
 export class Email implements Hashable {
   title!: string;
   address!: string;
@@ -383,6 +469,7 @@ export class DataProduct extends PackageableElement {
   description: string | undefined;
   icon: DataProductIcon | undefined;
   accessPointGroups: AccessPointGroup[] = [];
+  nativeModelAccess: NativeModelAccess | undefined;
   supportInfo: SupportInfo | undefined;
   type: DataProductType | undefined;
   sampleValues: EmbeddedData[] | undefined;
@@ -401,6 +488,7 @@ export class DataProduct extends PackageableElement {
       this.description ?? '',
       this.icon ?? '',
       hashArray(this.accessPointGroups),
+      this.nativeModelAccess ?? '',
       this.supportInfo ?? '',
       this.type ?? '',
       hashArray(this.stereotypes.map((val) => val.pointerHashCode)),

package/src/graph/metamodel/pure/packageableElements/service/Service.ts

@@ -35,6 +35,7 @@ export class Service extends PackageableElement implements Hashable, Testable {
   ownership: ServiceOwnership | undefined;
   documentation = '';
   autoActivateUpdates = true;
+  mcpServer?: string | undefined;
   execution!: ServiceExecution;
   test?: DEPRECATED__ServiceTest | undefined;
   tests: ServiceTestSuite[] = [];
@@ -63,6 +64,7 @@ export class Service extends PackageableElement implements Hashable, Testable {
       this.autoActivateUpdates.toString(),
       this.execution,
       this.test ?? '',
+      this.mcpServer ?? '',
       hashArray(this.tests),
       hashArray(this.postValidations),
       hashArray(this.taggedValues),

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

@@ -353,6 +353,7 @@ export const observe_Service = skipObservedWithContext(
       ownership: observable,
       documentation: observable,
       autoActivateUpdates: observable,
+      mcpServer: observable,
       execution: observable,
       test: observable,
       tests: observable,

package/src/graph-manager/action/validation/DSL_Service_ValidationHelper.ts

@@ -41,6 +41,25 @@ export const validate_ServicePattern = (
   return errors.length ? createValidationError(errors) : undefined;
 };
 
+export const validate_ServiceMcpServer = (
+  mcpServer: string | undefined,
+): ValidationIssue | undefined => {
+  const errors: string[] = [];
+  if (!mcpServer) {
+    return undefined;
+  } else {
+    // MCP server must be an identifier matching: ^[a-zA-Z_][a-zA-Z0-9_]*$
+    const MCP_SERVER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    if (!MCP_SERVER_REGEX.test(mcpServer)) {
+      addUniqueEntry(
+        errors,
+        `MCP server must match pattern '^[a-zA-Z_][a-zA-Z0-9_]*$'\n(start with a letter or underscore, followed by letters, digits, or underscores)`,
+      );
+    }
+  }
+  return errors.length ? createValidationError(errors) : undefined;
+};
+
 export const validate_PureExecutionQuery = (
   metamodel: PureExecution,
 ): ValidationIssue | undefined => {

package/src/graph-manager/protocol/pure/v1/lakehouse/deploy/V1_DataProductArtifact.ts

@@ -15,6 +15,9 @@
  */
 
 import {
+  deserializeMap,
+  optionalCustomList,
+  optionalCustomUsingModelSchema,
   SerializationFactory,
   UnsupportedOperationError,
   usingConstantValueSchema,
@@ -26,9 +29,11 @@ import {
   custom,
   deserialize,
   list,
+  object,
   optional,
   primitive,
   serialize,
+  SKIP,
 } from 'serializr';
 import type { V1_GenericType } from '../../model/packageableElements/type/V1_GenericType.js';
 import {
@@ -37,6 +42,10 @@ import {
 } from '../../transformation/pureProtocol/serializationHelpers/V1_TypeSerializationHelper.js';
 import type { V1_RelationElement } from '../../model/data/V1_EmbeddedData.js';
 import { V1_relationElementModelSchema } from '../../transformation/pureProtocol/serializationHelpers/V1_DataElementSerializationHelper.js';
+import { V1_pureModelContextDataPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization.js';
+import type { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData.js';
+import type { V1_Multiplicity } from '../../model/packageableElements/domain/V1_Multiplicity.js';
+import { V1_multiplicityModelSchema } from '../../transformation/pureProtocol/serializationHelpers/V1_CoreSerializationHelper.js';
 
 export enum V1_DataProductTypeEnum {
   INTERNAL = 'internalDataProductType',
@@ -48,6 +57,11 @@ export enum V1_ResourceBuilderType {
   FUNCTION_ACCESS_POINT = 'functionAccessPoint',
 }
 
+export enum V1_SampleQueryType {
+  IN_LINE_SAMPLE_QUERY = 'inLineSampleQuery',
+  PACKAGEABLE_ELEMENT_SAMPLE_QUERY = 'packageableElementSampleQuery',
+}
+
 export enum V1_DatabaseDDLImplementationType {
   VIEW = 'VIEW',
   TABLE = 'TABLE',
@@ -211,6 +225,282 @@ export class V1_AccessPointImplementation {
   );
 }
 
+export class V1_DatasetSpecification {
+  name!: string;
+  type!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DatasetSpecification, {
+      name: primitive(),
+      type: primitive(),
+    }),
+  );
+}
+
+export class V1_RuntimeGenerationInfo {
+  path!: string;
+  storePath?: string;
+  connectionType?: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_RuntimeGenerationInfo, {
+      path: primitive(),
+      storePath: optional(primitive()),
+      connectionType: optional(primitive()),
+    }),
+  );
+}
+
+export class V1_DiagramInfo {
+  title!: string;
+  description?: string;
+  diagram!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DiagramInfo, {
+      title: primitive(),
+      description: optional(primitive()),
+      diagram: primitive(),
+    }),
+  );
+}
+
+export class V1_MappingGenerationInfo {
+  path!: string;
+  model!: V1_PureModelContextData;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappingGenerationInfo, {
+      path: primitive(),
+      model: V1_pureModelContextDataPropSchema,
+    }),
+  );
+}
+
+export class V1_NativeModelExecutionContextInfo {
+  key!: string;
+  mapping!: string;
+  runtime?: V1_RuntimeGenerationInfo | undefined;
+  datasets: V1_DatasetSpecification[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_NativeModelExecutionContextInfo, {
+      key: primitive(),
+      mapping: primitive(),
+      runtime: optionalCustomUsingModelSchema(
+        V1_RuntimeGenerationInfo.serialization.schema,
+      ),
+      datasets: list(
+        usingModelSchema(V1_DatasetSpecification.serialization.schema),
+      ),
+    }),
+  );
+}
+
+export abstract class V1_SampleQueryInfo {
+  id!: string;
+  title!: string;
+  description?: string;
+  executionContextKey!: string;
+}
+
+export class V1_InLineSampleQueryInfo extends V1_SampleQueryInfo {
+  queryGrammar!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_InLineSampleQueryInfo, {
+      _type: usingConstantValueSchema(V1_SampleQueryType.IN_LINE_SAMPLE_QUERY),
+      id: primitive(),
+      title: primitive(),
+      description: optional(primitive()),
+      queryGrammar: primitive(),
+      executionContextKey: primitive(),
+    }),
+  );
+}
+
+export class V1_PackageableElementSampleQueryInfo extends V1_SampleQueryInfo {
+  queryPath!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_PackageableElementSampleQueryInfo, {
+      _type: usingConstantValueSchema(
+        V1_SampleQueryType.PACKAGEABLE_ELEMENT_SAMPLE_QUERY,
+      ),
+      id: primitive(),
+      title: primitive(),
+      description: optional(primitive()),
+      queryPath: primitive(),
+      executionContextKey: primitive(),
+    }),
+  );
+}
+
+const V1_deserializeSampleQuery = (
+  json: PlainObject<V1_SampleQueryInfo>,
+): V1_SampleQueryInfo => {
+  switch (json._type) {
+    case V1_SampleQueryType.IN_LINE_SAMPLE_QUERY:
+      return deserialize(V1_InLineSampleQueryInfo.serialization.schema, json);
+    case V1_SampleQueryType.PACKAGEABLE_ELEMENT_SAMPLE_QUERY:
+      return deserialize(
+        V1_PackageableElementSampleQueryInfo.serialization.schema,
+        json,
+      );
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize data product sample query of type '${json._type}'`,
+      );
+  }
+};
+
+export class V1_NativeModelAccessInfo {
+  diagrams: V1_DiagramInfo[] = [];
+  model!: V1_PureModelContextData;
+  elements: string[] = [];
+  defaultExecutionContext!: string;
+  elementDocs: V1_ModelDocumentationEntry[] = [];
+  mappingGenerations!: Map<string, V1_MappingGenerationInfo>;
+  nativeModelExecutionContexts!: V1_NativeModelExecutionContextInfo[];
+  sampleQueries?: V1_SampleQueryInfo[] | undefined;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_NativeModelAccessInfo, {
+      diagrams: list(usingModelSchema(V1_DiagramInfo.serialization.schema)),
+      model: V1_pureModelContextDataPropSchema,
+      elements: list(primitive()),
+      elementDocs: list(
+        custom(() => SKIP, V1_deserializeModelDocumentationEntry),
+      ),
+      defaultExecutionContext: primitive(),
+      nativeModelExecutionContexts: list(
+        usingModelSchema(
+          V1_NativeModelExecutionContextInfo.serialization.schema,
+        ),
+      ),
+      sampleQueries: optionalCustomList(
+        () => SKIP as never,
+        (val: PlainObject<V1_SampleQueryInfo>) =>
+          V1_deserializeSampleQuery(val),
+      ),
+      mappingGenerations: custom(
+        () => SKIP,
+        (val) =>
+          deserializeMap(val, (_val) =>
+            deserialize(V1_MappingGenerationInfo.serialization.schema, _val),
+          ),
+      ),
+    }),
+  );
+}
+
+export class V1_BasicDocumentationEntry {
+  name!: string;
+  docs: string[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_BasicDocumentationEntry, {
+      docs: list(primitive()),
+      name: primitive(),
+    }),
+  );
+}
+
+export class V1_PropertyDocumentationEntry extends V1_BasicDocumentationEntry {
+  milestoning?: string | undefined;
+  type?: string | undefined;
+  multiplicity!: V1_Multiplicity;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_PropertyDocumentationEntry, {
+      docs: list(primitive()),
+      milestoning: optional(primitive()),
+      multiplicity: usingModelSchema(V1_multiplicityModelSchema),
+      name: primitive(),
+      type: optional(primitive()),
+    }),
+  );
+}
+
+export class V1_ModelDocumentationEntry extends V1_BasicDocumentationEntry {
+  path!: string;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_ModelDocumentationEntry, {
+      docs: list(primitive()),
+      name: primitive(),
+      path: primitive(),
+    }),
+  );
+}
+
+export class V1_ClassDocumentationEntry extends V1_ModelDocumentationEntry {
+  properties: V1_PropertyDocumentationEntry[] = [];
+  milestoning?: string | undefined;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_ClassDocumentationEntry, {
+      docs: list(primitive()),
+      milestoning: optional(primitive()),
+      name: primitive(),
+      path: primitive(),
+      properties: list(object(V1_PropertyDocumentationEntry)),
+    }),
+  );
+}
+
+export class V1_EnumerationDocumentationEntry extends V1_ModelDocumentationEntry {
+  enumValues: V1_BasicDocumentationEntry[] = [];
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_EnumerationDocumentationEntry, {
+      enumValues: list(object(V1_BasicDocumentationEntry)),
+      docs: list(primitive()),
+      name: primitive(),
+      path: primitive(),
+    }),
+  );
+}
+
+export class V1_AssociationDocumentationEntry extends V1_ModelDocumentationEntry {
+  properties: V1_PropertyDocumentationEntry[] = [];
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_AssociationDocumentationEntry, {
+      docs: list(primitive()),
+      name: primitive(),
+      path: primitive(),
+      properties: list(object(V1_PropertyDocumentationEntry)),
+    }),
+  );
+}
+
+enum V1_ModelDocumentationEntryType {
+  MODEL = 'model',
+  CLASS = 'class',
+  ENUMERATION = 'enumeration',
+  ASSOCIATION = 'association',
+}
+
+function V1_deserializeModelDocumentationEntry(
+  json: PlainObject<V1_ModelDocumentationEntry>,
+): V1_ModelDocumentationEntry {
+  switch (json._type) {
+    case V1_ModelDocumentationEntryType.MODEL:
+      return V1_ModelDocumentationEntry.serialization.fromJson(json);
+    case V1_ModelDocumentationEntryType.CLASS:
+      return V1_ClassDocumentationEntry.serialization.fromJson(json);
+    case V1_ModelDocumentationEntryType.ENUMERATION:
+      return V1_EnumerationDocumentationEntry.serialization.fromJson(json);
+    case V1_ModelDocumentationEntryType.ASSOCIATION:
+      return V1_AssociationDocumentationEntry.serialization.fromJson(json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize model documentation entry of type '${json._type}'`,
+      );
+  }
+}
+
 export class V1_AccessPointGroupInfo {
   id!: string;
   description: string | undefined;
@@ -230,6 +520,7 @@ export class V1_AccessPointGroupInfo {
 export class V1_DataProductArtifact {
   dataProduct!: V1_DataProductInfo;
   accessPointGroups: V1_AccessPointGroupInfo[] = [];
+  nativeModelAccess?: V1_NativeModelAccessInfo | undefined;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataProductArtifact, {
@@ -237,6 +528,9 @@ export class V1_DataProductArtifact {
       accessPointGroups: list(
         usingModelSchema(V1_AccessPointGroupInfo.serialization.schema),
       ),
+      nativeModelAccess: optionalCustomUsingModelSchema(
+        V1_NativeModelAccessInfo.serialization.schema,
+      ),
     }),
   );
 }

package/src/graph-manager/protocol/pure/v1/lakehouse/entitlements/V1_ConsumerEntitlements.ts

@@ -65,6 +65,12 @@ export class V1_DataContractsResponse {
   dataContracts?: V1_DataContractSubscriptions[];
 }
 
+export class V1_InvalidateDataContractResponse {
+  contractId!: string;
+  invalidated!: boolean;
+  requestId!: string;
+}
+
 // -------------------------------------- Lite Data Contracts ------------------------------------------
 
 export class V1_LiteDataContract {

package/src/graph-manager/protocol/pure/v1/model/packageableElements/dataProduct/V1_DataProduct.ts

@@ -220,6 +220,81 @@ export class V1_ModelAccessPointGroup extends V1_AccessPointGroup {
   }
 }
 
+export class V1_NativeModelExecutionContext {
+  key!: string;
+  mapping!: V1_PackageableElementPointer;
+  runtime: V1_PackageableElementPointer | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_NATIVE_MODEL_ACCESS,
+      this.mapping.path,
+      this.runtime?.path ?? '',
+      this.key,
+    ]);
+  }
+}
+
+export class V1_NativeModelAccess {
+  featuredElements: V1_ElementScope[] | undefined;
+  nativeModelExecutionContexts!: V1_NativeModelExecutionContext[];
+  defaultExecutionContext!: string;
+  diagrams: V1_DataProductDiagram[] | undefined;
+  sampleQueries: V1_SampleQuery[] | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_NATIVE_MODEL_ACCESS,
+      hashArray(this.nativeModelExecutionContexts),
+      hashArray(this.featuredElements ?? []),
+      hashArray(this.diagrams ?? []),
+      hashArray(this.sampleQueries ?? []),
+      this.defaultExecutionContext,
+    ]);
+  }
+}
+
+export abstract class V1_SampleQuery {
+  id!: string;
+  title!: string;
+  description: string | undefined;
+  executionContextKey: string | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_SAMPLE_QUERY,
+      this.id,
+      this.title,
+      this.description ?? '',
+      this.executionContextKey ?? '',
+    ]);
+  }
+}
+
+export class V1_InLineSampleQuery extends V1_SampleQuery {
+  query!: V1_RawLambda;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_INLINE_SAMPLE_QUERY,
+      super.hashCode,
+      this.query,
+    ]);
+  }
+}
+
+export class V1_PackageableElementSampleQuery extends V1_SampleQuery {
+  query!: V1_PackageableElementPointer;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_PACKAGEABLE_ELEMENT_SAMPLE_QUERY,
+      super.hashCode,
+      this.query.path,
+    ]);
+  }
+}
+
 export enum V1_DeliveryFrequency {
   DAILY = 'DAILY',
   WEEKLY = 'WEEKLY',
@@ -337,6 +412,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
   description: string | undefined;
   icon: V1_DataProductIcon | undefined;
   accessPointGroups: V1_AccessPointGroup[] = [];
+  nativeModelAccess: V1_NativeModelAccess | undefined;
   supportInfo: V1_SupportInfo | undefined;
   type: V1_DataProductType | undefined;
   stereotypes: V1_StereotypePtr[] = [];
@@ -351,6 +427,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
       this.description ?? '',
       this.icon ?? '',
       hashArray(this.accessPointGroups),
+      this.nativeModelAccess ?? '',
       this.supportInfo ?? '',
       this.type ?? '',
       hashArray(this.stereotypes),

package/src/graph-manager/protocol/pure/v1/model/packageableElements/service/V1_Service.ts

@@ -35,6 +35,7 @@ export class V1_Service extends V1_PackageableElement implements Hashable {
   owners: string[] = [];
   ownership?: V1_ServiceOwnership | undefined;
   documentation!: string;
+  mcpServer?: string | undefined;
   autoActivateUpdates = true;
   execution!: V1_ServiceExecution;
   test?: V1_DEPRECATED__ServiceTest | undefined;
@@ -54,6 +55,7 @@ export class V1_Service extends V1_PackageableElement implements Hashable {
       this.autoActivateUpdates.toString(),
       this.execution,
       this.test ?? '',
+      this.mcpServer ?? '',
       hashArray(this.testSuites),
       hashArray(this.postValidations),
       hashArray(this.taggedValues),