@finos/legend-graph 32.3.22 → 32.3.23

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/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),

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/from/V1_DataProductTransformer.ts

@@ -28,6 +28,8 @@ import {
   UnknownAccessPoint,
   UnknownDataProductIcon,
   FunctionAccessPoint,
+  PackageableElementSampleQuery,
+  InLineSampleQuery,
 } from '../../../../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
 import {
   type V1_AccessPoint,
@@ -51,6 +53,10 @@ import {
   V1_FunctionAccessPoint,
   type V1_Expertise,
   V1_DataProductOperationalMetadata,
+  V1_NativeModelAccess,
+  V1_PackageableElementSampleQuery,
+  V1_InLineSampleQuery,
+  V1_NativeModelExecutionContext,
 } from '../../../model/packageableElements/dataProduct/V1_DataProduct.js';
 import { V1_initPackageableElement } from './V1_CoreTransformerHelper.js';
 import { V1_transformRawLambda } from './V1_RawValueSpecificationTransformer.js';
@@ -61,6 +67,8 @@ import {
 } from './V1_DomainTransformer.js';
 import { V1_PackageableElementPointer } from '../../../model/packageableElements/V1_PackageableElement.js';
 import { V1_transformEmbeddedData } from './V1_DataElementTransformer.js';
+import { ConcreteFunctionDefinition } from '../../../../../../../graph/metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
+import { generateFunctionPrettyName } from '../../../../../../../graph/helpers/PureLanguageHelper.js';
 
 const transformAccessPoint = (
   ap: AccessPoint,
@@ -137,6 +145,103 @@ export const V1_transformDataProduct = (
     product.type = dataProductType;
   }
 
+  if (element.nativeModelAccess) {
+    const nativeModelAccess = new V1_NativeModelAccess();
+    const metamodelNativeModelAccess = element.nativeModelAccess;
+    if (metamodelNativeModelAccess.diagrams.length === 0) {
+      nativeModelAccess.diagrams = undefined;
+    } else {
+      nativeModelAccess.diagrams = metamodelNativeModelAccess.diagrams.map(
+        (diagram) => {
+          const v1Diagram = new V1_DataProductDiagram();
+          v1Diagram.title = diagram.title;
+          v1Diagram.description = diagram.description;
+          v1Diagram.diagram = new V1_PackageableElementPointer(
+            undefined,
+            diagram.diagram.path,
+          );
+          return v1Diagram;
+        },
+      );
+    }
+    nativeModelAccess.defaultExecutionContext =
+      metamodelNativeModelAccess.defaultExecutionContext;
+    nativeModelAccess.nativeModelExecutionContexts =
+      metamodelNativeModelAccess.nativeModelExecutionContexts.map(
+        (executionContext) => {
+          const v1ExecutionContext = new V1_NativeModelExecutionContext();
+          v1ExecutionContext.key = executionContext.key;
+          v1ExecutionContext.mapping = new V1_PackageableElementPointer(
+            undefined,
+            executionContext.mapping.valueForSerialization ?? '',
+          );
+          if (executionContext.runtime) {
+            v1ExecutionContext.runtime = new V1_PackageableElementPointer(
+              undefined,
+              executionContext.runtime.valueForSerialization ?? '',
+            );
+          }
+          return v1ExecutionContext;
+        },
+      );
+    nativeModelAccess.featuredElements =
+      metamodelNativeModelAccess.featuredElements.map((metatamodelScope) => {
+        const scope = new V1_ElementScope();
+        scope.exclude = metatamodelScope.exclude;
+        scope.element = new V1_PackageableElementPointer(
+          undefined,
+          metatamodelScope.element.valueForSerialization ?? '',
+        );
+        return scope;
+      });
+    nativeModelAccess.sampleQueries =
+      metamodelNativeModelAccess.sampleQueries.map((metamodelSampleQuery) => {
+        if (metamodelSampleQuery instanceof PackageableElementSampleQuery) {
+          const sampleQuery = new V1_PackageableElementSampleQuery();
+          sampleQuery.id = metamodelSampleQuery.id;
+          sampleQuery.title = metamodelSampleQuery.title;
+          sampleQuery.description = metamodelSampleQuery.description;
+          sampleQuery.executionContextKey =
+            metamodelSampleQuery.executionContextKey;
+          if (
+            metamodelSampleQuery.query.value instanceof
+            ConcreteFunctionDefinition
+          ) {
+            sampleQuery.query = new V1_PackageableElementPointer(
+              undefined,
+              generateFunctionPrettyName(metamodelSampleQuery.query.value, {
+                fullPath: true,
+                spacing: false,
+                notIncludeParamName: true,
+              }),
+            );
+          } else {
+            sampleQuery.query = new V1_PackageableElementPointer(
+              undefined,
+              metamodelSampleQuery.query.valueForSerialization ?? '',
+            );
+          }
+          return sampleQuery;
+        } else if (metamodelSampleQuery instanceof InLineSampleQuery) {
+          const sampleQuery = new V1_InLineSampleQuery();
+          sampleQuery.id = metamodelSampleQuery.id;
+          sampleQuery.title = metamodelSampleQuery.title;
+          sampleQuery.description = metamodelSampleQuery.description;
+          sampleQuery.executionContextKey =
+            metamodelSampleQuery.executionContextKey;
+          sampleQuery.query = V1_transformRawLambda(
+            metamodelSampleQuery.query,
+            context,
+          );
+          return sampleQuery;
+        }
+        throw new UnsupportedOperationError(
+          `Unable to transform data product sample query`,
+        );
+      });
+    product.nativeModelAccess = nativeModelAccess;
+  }
+
   if (!element.icon) {
     product.icon = undefined;
   } else {

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/from/V1_ServiceTransformer.ts

@@ -332,6 +332,7 @@ export const V1_transformService = (
   service.stereotypes = element.stereotypes.map(V1_transformStereotype);
   service.taggedValues = element.taggedValues.map(V1_transformTaggedValue);
   service.autoActivateUpdates = element.autoActivateUpdates;
+  service.mcpServer = element.mcpServer;
   service.documentation = element.documentation;
   service.execution = transformServiceExecution(element.execution, context);
   if (element.ownership) {

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementSecondPassBuilder.ts

@@ -143,6 +143,7 @@ import {
   V1_buildDataProductIcon,
   V1_buildDataProductLink,
   V1_buildDataProductOperationalMetadata,
+  V1_buildNativeModelAccess,
 } from './helpers/V1_DataProductBuilder.js';
 import type { V1_IngestDefinition } from '../../../model/packageableElements/ingest/V1_IngestDefinition.js';
 import { IncludeStore } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/model/IncludeStore.js';
@@ -619,6 +620,7 @@ export class V1_ElementSecondPassBuilder
     service.owners = element.owners.slice();
     service.documentation = element.documentation;
     service.autoActivateUpdates = element.autoActivateUpdates;
+    service.mcpServer = element.mcpServer;
     if (element.ownership) {
       service.ownership = V1_buildServiceOwnership(element.ownership, service);
     }
@@ -751,6 +753,12 @@ export class V1_ElementSecondPassBuilder
     dataProduct.accessPointGroups = element.accessPointGroups.map((gr) =>
       V1_buildAccessPointGroup(gr, this.context),
     );
+    if (element.nativeModelAccess) {
+      dataProduct.nativeModelAccess = V1_buildNativeModelAccess(
+        element.nativeModelAccess,
+        this.context,
+      );
+    }
     const protocolSupportInfo = element.supportInfo;
     if (protocolSupportInfo) {
       const supportInfo = new SupportInfo();