@finos/legend-graph 32.4.2 → 32.5.0

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

@@ -30,6 +30,7 @@ import type {
 } from './compilation/V1_LambdaReturnType.js';
 import type { V1_ServiceRegistrationResult } from './service/V1_ServiceRegistrationResult.js';
 import type { V1_ServiceConfigurationInfo } from './service/V1_ServiceConfiguration.js';
+import { ServiceDetail } from '../../../../action/service/ServiceDetail.js';
 import type { V1_CompileResult } from './compilation/V1_CompileResult.js';
 import type { V1_RawLambda } from '../model/rawValueSpecification/V1_RawLambda.js';
 import type { V1_GenerateFileInput } from './generation/V1_FileGenerationInput.js';
@@ -1238,4 +1239,14 @@ export class V1_EngineServerClient extends AbstractServerClient {
       `${this._devMetadata()}`,
       request,
     );
+
+  // ------------------------------------------- Legend Services List -------------------------------------------
+
+  private readonly getServicesDetailsFromCache = (): Promise<PlainObject[]> =>
+    this.get(`${this._service()}/list/detailsFromCache`);
+
+  getServicesInfo = async (): Promise<ServiceDetail[]> => {
+    const raw = await this.getServicesDetailsFromCache();
+    return raw.map((r) => ServiceDetail.fromJson(r));
+  };
 }

package/src/graph-manager/protocol/pure/v1/helpers/V1_AccessorHelper.ts

@@ -0,0 +1,156 @@
+/**
+ * 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 Accessor,
+  IngestionAccessor,
+  RelationalStoreAccessor,
+  type AccessorOwner,
+} from '../../../../../graph/metamodel/pure/packageableElements/relation/Accessor.js';
+import {
+  RelationType,
+  RelationColumn,
+} from '../../../../../graph/metamodel/pure/packageableElements/relation/RelationType.js';
+import { GenericType } from '../../../../../graph/metamodel/pure/packageableElements/domain/GenericType.js';
+import { GenericTypeExplicitReference } from '../../../../../graph/metamodel/pure/packageableElements/domain/GenericTypeReference.js';
+import { IngestDefinition } from '../../../../../graph/metamodel/pure/packageableElements/ingest/IngestDefinition.js';
+import { Database } from '../../../../../graph/metamodel/pure/packageableElements/store/relational/model/Database.js';
+import { Column } from '../../../../../graph/metamodel/pure/packageableElements/store/relational/model/Column.js';
+import type { Table } from '../../../../../graph/metamodel/pure/packageableElements/store/relational/model/Table.js';
+import { mapRelationalDataTypeToPrimitiveType } from '../../../../../graph/helpers/STO_Relational_Helper.js';
+import type { V1_IngestDataset } from '../model/packageableElements/ingest/V1_IngestDefinition.js';
+import type { V1_GraphBuilderContext } from '../transformation/pureGraph/to/V1_GraphBuilderContext.js';
+import { V1_GenericType as V1_GenericTypeProtocol } from '../model/packageableElements/type/V1_GenericType.js';
+import { V1_PackageableType } from '../model/packageableElements/type/V1_PackageableType.js';
+import { returnUndefOnError } from '@finos/legend-shared';
+import { V1_deserializeIngestDefinitionContent } from '../transformation/pureProtocol/serializationHelpers/V1_IngestSerializationHelper.js';
+
+const buildV1GenericType = (fullPath: string): V1_GenericTypeProtocol => {
+  // Strip package prefix — primitive types are indexed by simple name
+  const typeName = fullPath.includes('::')
+    ? fullPath.substring(fullPath.lastIndexOf('::') + 2)
+    : fullPath;
+  const rawType = new V1_PackageableType();
+  rawType.fullPath = typeName;
+  const genericType = new V1_GenericTypeProtocol();
+  genericType.rawType = rawType;
+  return genericType;
+};
+
+const buildRelationTypeFromIngestDataset = (
+  dataset: V1_IngestDataset,
+  context: V1_GraphBuilderContext,
+): RelationType => {
+  const relationType = new RelationType('__ingest_dataset__');
+  relationType.columns = dataset.source.schema.columns.map((col) => {
+    const rawTypePath =
+      col.genericType.rawType instanceof V1_PackageableType
+        ? col.genericType.rawType.fullPath
+        : 'String';
+    const v1GenericType = buildV1GenericType(rawTypePath);
+    const resolvedGenericType =
+      returnUndefOnError(() =>
+        context.resolveGenericTypeFromProtocolWithRelationType(v1GenericType),
+      ) ??
+      context.resolveGenericTypeFromProtocolWithRelationType(
+        buildV1GenericType('String'),
+      );
+    return new RelationColumn(col.name, resolvedGenericType);
+  });
+  return relationType;
+};
+
+const buildRelationTypeFromTable = (table: Table): RelationType => {
+  const relationType = new RelationType('__database_table__');
+  relationType.columns = table.columns
+    .filter((col): col is Column => col instanceof Column)
+    .map(
+      (col) =>
+        new RelationColumn(
+          col.name,
+          GenericTypeExplicitReference.create(
+            new GenericType(mapRelationalDataTypeToPrimitiveType(col.type)),
+          ),
+        ),
+    );
+  return relationType;
+};
+// TODO: move to pure graph
+/**
+ * Creates an appropriate Accessor from a packageable element.
+ *
+ * For IngestDefinition: requires `datasetName` to identify the dataset.
+ * For Database: requires `schemaName` and `tableName` to identify the table.
+ */
+export const V1_createAccessorFromPackageableElement = (
+  element: AccessorOwner,
+  context: V1_GraphBuilderContext,
+  options?: {
+    schemaName?: string | undefined;
+    tableName?: string | undefined;
+  },
+): Accessor | undefined => {
+  if (element instanceof IngestDefinition) {
+    const content = returnUndefOnError(() =>
+      V1_deserializeIngestDefinitionContent(element.content),
+    );
+    // if unable to serialize we dont fall hard, we return undefined. we may want to revisit and fall hard on this.
+    if (!content) {
+      return undefined;
+    }
+    const datasetName = options?.tableName;
+    const dataset = datasetName
+      ? content.datasets?.find((ds) => ds.name === datasetName)
+      : content.datasets?.[0];
+    if (!dataset) {
+      return undefined;
+    }
+    const relationType = buildRelationTypeFromIngestDataset(dataset, context);
+    return new IngestionAccessor(
+      element.path,
+      undefined,
+      dataset.name,
+      relationType,
+      element,
+    );
+  }
+  if (element instanceof Database) {
+    const schemaName = options?.schemaName;
+    const tableName = options?.tableName;
+    let table: Table | undefined;
+    if (schemaName && tableName) {
+      const schema = element.schemas.find((s) => s.name === schemaName);
+      if (!schema) {
+        return undefined;
+      }
+      table = schema.tables.find((t) => t.name === tableName);
+    }
+    const tables = element.schemas.map((e) => e.tables).flat();
+    table = tableName ? tables.find((t) => t.name === tableName) : tables[0];
+    if (!table) {
+      return undefined;
+    }
+    const relationType = buildRelationTypeFromTable(table);
+    return new RelationalStoreAccessor(
+      element.path,
+      table.schema.name,
+      table.name,
+      relationType,
+      element,
+    );
+  }
+  return undefined;
+};

package/src/graph-manager/protocol/pure/v1/helpers/V1_ValueSpecificationObserver.ts

@@ -20,7 +20,7 @@ import {
   type V1_ValueSpecificationVisitor,
 } from '../model/valueSpecification/V1_ValueSpecification.js';
 import type { V1_Variable } from '../model/valueSpecification/V1_Variable.js';
-import type { V1_Lambda } from '../model/valueSpecification/raw/V1_Lambda.js';
+import { V1_Lambda } from '../model/valueSpecification/raw/V1_Lambda.js';
 import type { V1_EnumValue } from '../model/valueSpecification/raw/V1_EnumValue.js';
 import type { V1_AppliedFunction } from '../model/valueSpecification/application/V1_AppliedFunction.js';
 import type { V1_Collection } from '../model/valueSpecification/raw/V1_Collection.js';
@@ -380,10 +380,10 @@ function _V1_observe_ColSpec(metamodel: V1_ColSpec): V1_ColSpec {
     function2: observable,
   });
 
-  if (metamodel.function1) {
+  if (metamodel.function1 && metamodel.function1 instanceof V1_Lambda) {
     V1_observe_Lambda(metamodel.function1);
   }
-  if (metamodel.function2) {
+  if (metamodel.function2 && metamodel.function2 instanceof V1_Lambda) {
     V1_observe_Lambda(metamodel.function2);
   }
 

package/src/graph-manager/protocol/pure/v1/model/packageableElements/ingest/V1_IngestDefinition.ts

@@ -30,18 +30,22 @@ export class V1_IngestDefinition extends V1_INTERNAL__UnknownPackageableElement
     return visitor.visit_IngestDefinition(this);
   }
 }
-export interface V1_IngestDataset {
-  name: string;
-  primaryKey: string[];
-  source: {
-    _type: string;
-    schema: {
-      _type: string;
-      columns: V1_RelationTypeColumn[];
-    };
-  };
+export class V1_IngestDatasetSchema {
+  _type!: string;
+  columns: V1_RelationTypeColumn[] = [];
 }
 
-export interface V1_IngestDefinitionContent {
+export class V1_IngestDatasetSource {
+  _type!: string;
+  schema!: V1_IngestDatasetSchema;
+}
+
+export class V1_IngestDataset {
+  name!: string;
+  primaryKey: string[] = [];
+  source!: V1_IngestDatasetSource;
+}
+
+export class V1_IngestDefinitionContent {
   datasets?: V1_IngestDataset[];
 }

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;
+  title?: string | undefined;
   mcpServer?: string | undefined;
   autoActivateUpdates = true;
   execution!: V1_ServiceExecution;
@@ -56,6 +57,7 @@ export class V1_Service extends V1_PackageableElement implements Hashable {
       this.execution,
       this.test ?? '',
       this.mcpServer ?? '',
+      this.title ?? '',
       hashArray(this.testSuites),
       hashArray(this.postValidations),
       hashArray(this.taggedValues),

package/src/graph-manager/protocol/pure/v1/model/valueSpecification/raw/classInstance/relation/V1_ColSpec.ts

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-import type { V1_Lambda } from '../../V1_Lambda.js';
+import type { V1_ValueSpecification } from '../../../V1_ValueSpecification.js';
 
 export class V1_ColSpec {
   name!: string;
   type?: string | undefined;
-  function1?: V1_Lambda | undefined;
-  function2?: V1_Lambda | undefined;
+  function1?: V1_ValueSpecification | undefined;
+  function2?: V1_ValueSpecification | undefined;
 }

package/src/graph-manager/protocol/pure/v1/model/valueSpecification/raw/classInstance/relation/V1_RelationStoreAccessor.ts

@@ -14,16 +14,41 @@
  * limitations under the License.
  */
 
-export class V1_RelationStoreAccessor {
+import { V1_ClassInstanceType } from '../../../../../transformation/pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer.js';
+
+export abstract class V1_Accessor {
   path: string[] = [];
+
+  abstract INSTANCE_TYPE: V1_ClassInstanceType;
+}
+
+export class V1_RelationStoreAccessor extends V1_Accessor {
   metadata?: boolean;
+
+  get INSTANCE_TYPE(): V1_ClassInstanceType {
+    return V1_ClassInstanceType.RELATION_STORE_ACCESSOR;
+  }
 }
 
-export class V1_DataProductAccessor {
-  path: string[] = [];
+export class V1_DataProductAccessor extends V1_Accessor {
   parameters: string[] = [];
+  get INSTANCE_TYPE(): V1_ClassInstanceType {
+    return V1_ClassInstanceType.DATA_PRODUCT_ACCESSOR;
+  }
 }
 
-export class V1_SQLAccessor {
+export class V1_IngestDefinitionAccessor extends V1_Accessor {
+  metadata = false;
+
+  get INSTANCE_TYPE(): V1_ClassInstanceType {
+    return V1_ClassInstanceType.INGEST_ACCESSOR;
+  }
+}
+
+export class V1_SQLAccessor extends V1_Accessor {
   sql!: string;
+
+  get INSTANCE_TYPE(): V1_ClassInstanceType {
+    return V1_ClassInstanceType.SQL_ACCESSOR;
+  }
 }

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

@@ -329,25 +329,26 @@ export const V1_transformService = (
 ): V1_Service => {
   const service = new V1_Service();
   V1_initPackageableElement(service, element);
-  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);
+  service.mcpServer = element.mcpServer;
+  service.owners = element.owners;
   if (element.ownership) {
     service.ownership = transformServiceOwnership(element.ownership);
   }
-  service.owners = element.owners;
   service.pattern = element.pattern;
+  service.postValidations = element.postValidations.map((postValidation) =>
+    V1_transformPostValidation(postValidation, context),
+  );
+  service.stereotypes = element.stereotypes.map(V1_transformStereotype);
+  service.taggedValues = element.taggedValues.map(V1_transformTaggedValue);
   if (element.test) {
     service.test = transformLegacyServiceTest(element.test, context);
   }
   service.testSuites = element.tests.map((testSuite) =>
     V1_transformTestSuite(testSuite, context),
   );
-  service.postValidations = element.postValidations.map((postValidation) =>
-    V1_transformPostValidation(postValidation, context),
-  );
+  service.title = element.title;
   return service;
 };

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

@@ -94,6 +94,39 @@ import { V1_ColSpecArray } from '../../../model/valueSpecification/raw/classInst
 import { V1_ColSpec } from '../../../model/valueSpecification/raw/classInstance/relation/V1_ColSpec.js';
 import { RelationColumn } from '../../../../../../../graph/metamodel/pure/packageableElements/relation/RelationType.js';
 import { V1_createGenericTypeWithElementPath } from '../../../helpers/V1_DomainHelper.js';
+import {
+  type Accessor,
+  type AccessorInstanceValue,
+  DataProductAccessor,
+  IngestionAccessor,
+  RelationalStoreAccessor,
+} from '../../../../../../../graph/metamodel/pure/packageableElements/relation/Accessor.js';
+import {
+  type V1_Accessor,
+  V1_DataProductAccessor,
+  V1_IngestDefinitionAccessor,
+  V1_RelationStoreAccessor,
+} from '../../../model/valueSpecification/raw/classInstance/relation/V1_RelationStoreAccessor.js';
+
+const transformAccessor = (accessor: Accessor): V1_Accessor => {
+  if (accessor instanceof DataProductAccessor) {
+    const v1Accessor = new V1_DataProductAccessor();
+    v1Accessor.path = accessor.path;
+    return v1Accessor;
+  } else if (accessor instanceof IngestionAccessor) {
+    const v1Accessor = new V1_IngestDefinitionAccessor();
+    v1Accessor.path = accessor.path;
+    return v1Accessor;
+  } else if (accessor instanceof RelationalStoreAccessor) {
+    const v1Accessor = new V1_RelationStoreAccessor();
+    v1Accessor.path = accessor.path;
+    return v1Accessor;
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform accessor: unsupported accessor type`,
+    accessor,
+  );
+};
 
 class V1_ValueSpecificationTransformer
   implements ValueSpecificationVisitor<V1_ValueSpecification>
@@ -254,6 +287,20 @@ class V1_ValueSpecificationTransformer
     );
   }
 
+  visit_AccessorInstanceValue(
+    valueAccessorInstanceValue: AccessorInstanceValue,
+  ): V1_ValueSpecification {
+    const accessor = guaranteeNonNullable(
+      valueAccessorInstanceValue.values[0],
+      'Accessor required in AccessorInstanceValue',
+    );
+    const v1Accessor = transformAccessor(accessor);
+    const classInstance = new V1_ClassInstance();
+    classInstance.type = v1Accessor.INSTANCE_TYPE;
+    classInstance.value = v1Accessor;
+    return classInstance;
+  }
+
   visit_CollectionInstanceValue(
     valueSpecification: CollectionInstanceValue,
   ): V1_ValueSpecification {
@@ -428,10 +475,10 @@ class V1_ValueSpecificationTransformer
         ),
       );
       if (fun1) {
-        colProtocol.function1 = guaranteeType(fun1, V1_Lambda);
+        colProtocol.function1 = fun1;
       }
       if (fun2) {
-        colProtocol.function2 = guaranteeType(fun2, V1_Lambda);
+        colProtocol.function2 = fun2;
       }
       return colProtocol;
     });

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

@@ -619,6 +619,7 @@ export class V1_ElementSecondPassBuilder
       .map((taggedValue) => V1_buildTaggedValue(taggedValue, this.context))
       .filter(isNonNullable);
     service.pattern = element.pattern;
+    service.title = element.title;
     service.owners = element.owners.slice();
     service.documentation = element.documentation;
     service.autoActivateUpdates = element.autoActivateUpdates;

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

@@ -116,9 +116,21 @@ import {
 } from '../../../../helpers/V1_DomainHelper.js';
 import {
   ColSpec,
+  ColSpecArray,
+  ColSpecArrayInstance,
   ColSpecInstanceValue,
 } from '../../../../../../../../graph/metamodel/pure/valueSpecification/RelationValueSpecification.js';
 import { V1_ColSpec } from '../../../../model/valueSpecification/raw/classInstance/relation/V1_ColSpec.js';
+import { V1_ColSpecArray } from '../../../../model/valueSpecification/raw/classInstance/relation/V1_ColSpecArray.js';
+import {
+  V1_RelationStoreAccessor,
+  V1_IngestDefinitionAccessor,
+  V1_DataProductAccessor,
+} from '../../../../model/valueSpecification/raw/classInstance/relation/V1_RelationStoreAccessor.js';
+import { AccessorInstanceValue } from '../../../../../../../../graph/metamodel/pure/packageableElements/relation/Accessor.js';
+import { V1_createAccessorFromPackageableElement } from '../../../../helpers/V1_AccessorHelper.js';
+import { Database } from '../../../../../../../../graph/metamodel/pure/packageableElements/store/relational/model/Database.js';
+import { IngestDefinition } from '../../../../../../../../graph/metamodel/pure/packageableElements/ingest/IngestDefinition.js';
 
 const buildPrimtiveInstanceValue = (
   type: PRIMITIVE_TYPE,
@@ -471,9 +483,125 @@ export class V1_ValueSpecificationBuilder
         const protocol = guaranteeType(valueSpecification.value, V1_ColSpec);
         const value = new ColSpec();
         value.name = protocol.name;
+        value.type = protocol.type;
+        value.function1 = protocol.function1
+          ? protocol.function1.accept_ValueSpecificationVisitor(
+              new V1_ValueSpecificationBuilder(
+                this.context,
+                this.processingContext,
+                this.openVariables,
+              ),
+            )
+          : undefined;
+        value.function2 = protocol.function2
+          ? protocol.function2.accept_ValueSpecificationVisitor(
+              new V1_ValueSpecificationBuilder(
+                this.context,
+                this.processingContext,
+                this.openVariables,
+              ),
+            )
+          : undefined;
         instanceValue.values = [value];
         return instanceValue;
       }
+      case V1_ClassInstanceType.COL_SPEC_ARRAY: {
+        const instanceValue = new ColSpecArrayInstance(
+          Multiplicity.ONE,
+          undefined,
+        );
+        const protocol = guaranteeType(
+          valueSpecification.value,
+          V1_ColSpecArray,
+        );
+        const value = new ColSpecArray();
+        value.colSpecs = protocol.colSpecs.map((colSpec) => {
+          const colSpecInstance = new ColSpec();
+          colSpecInstance.name = colSpec.name;
+          colSpecInstance.type = colSpec.type;
+          colSpecInstance.function1 = colSpec.function1
+            ? colSpec.function1.accept_ValueSpecificationVisitor(
+                new V1_ValueSpecificationBuilder(
+                  this.context,
+                  this.processingContext,
+                  this.openVariables,
+                ),
+              )
+            : undefined;
+          colSpecInstance.function2 = colSpec.function2
+            ? colSpec.function2.accept_ValueSpecificationVisitor(
+                new V1_ValueSpecificationBuilder(
+                  this.context,
+                  this.processingContext,
+                  this.openVariables,
+                ),
+              )
+            : undefined;
+          return colSpecInstance;
+        });
+        instanceValue.values = [value];
+        return instanceValue;
+      }
+      case V1_ClassInstanceType.RELATION_STORE_ACCESSOR: {
+        const protocol = guaranteeType(
+          valueSpecification.value,
+          V1_RelationStoreAccessor,
+        );
+        const dbPath = guaranteeNonNullable(protocol.path[0]);
+        const schemaName = protocol.path[1];
+        const tableName = protocol.path[2];
+        const db = guaranteeType(
+          this.context.resolveElement(dbPath, false).value,
+          Database,
+        );
+        const accessor = guaranteeNonNullable(
+          V1_createAccessorFromPackageableElement(db, this.context, {
+            schemaName,
+            tableName,
+          }),
+          `Can't build accessor for database '${dbPath}'`,
+        );
+        const accessorInstanceValue = new AccessorInstanceValue();
+        accessorInstanceValue.values = [accessor];
+        accessorInstanceValue.genericType = GenericTypeExplicitReference.create(
+          new GenericType(accessor.relationType),
+        );
+        return accessorInstanceValue;
+      }
+      case V1_ClassInstanceType.INGEST_ACCESSOR: {
+        const protocol = guaranteeType(
+          valueSpecification.value,
+          V1_IngestDefinitionAccessor,
+        );
+        const ingestPath = guaranteeNonNullable(protocol.path[0]);
+        const datasetName = protocol.path[1];
+        const ingestDef = guaranteeType(
+          this.context.resolveElement(ingestPath, false).value,
+          IngestDefinition,
+        );
+        const accessor = guaranteeNonNullable(
+          V1_createAccessorFromPackageableElement(ingestDef, this.context, {
+            tableName: datasetName,
+          }),
+          `Can't build accessor for ingest definition '${ingestPath}'`,
+        );
+        const accessorInstanceValue = new AccessorInstanceValue();
+        accessorInstanceValue.values = [accessor];
+        accessorInstanceValue.genericType = GenericTypeExplicitReference.create(
+          new GenericType(accessor.relationType),
+        );
+        return accessorInstanceValue;
+      }
+      case V1_ClassInstanceType.DATA_PRODUCT_ACCESSOR: {
+        const protocol = guaranteeType(
+          valueSpecification.value,
+          V1_DataProductAccessor,
+        );
+        const _path = protocol.path;
+        throw new UnsupportedOperationError(
+          `Can't build accessor for data product with path '${_path.join('.')}': data product accessor building is not yet supported`,
+        );
+      }
       default: {
         const builders = this.context.extensions.plugins.flatMap(
           (plugin) => plugin.V1_getExtraClassInstanceValueBuilders?.() ?? [],
@@ -609,6 +737,7 @@ export function V1_processProperty(
     const _funcExp = new FunctionExpression(col.name);
     _funcExp.func = col;
     _funcExp.parametersValues = processedParameters;
+    _funcExp.genericType = col.genericType;
     return _funcExp;
   }
   throw new UnsupportedOperationError(

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/serializationHelpers/V1_IngestSerializationHelper.ts

@@ -20,7 +20,13 @@ import {
   usingModelSchema,
   type PlainObject,
 } from '@finos/legend-shared';
-import { V1_IngestDefinition } from '../../../model/packageableElements/ingest/V1_IngestDefinition.js';
+import {
+  V1_IngestDataset,
+  V1_IngestDatasetSchema,
+  V1_IngestDatasetSource,
+  V1_IngestDefinition,
+  V1_IngestDefinitionContent,
+} from '../../../model/packageableElements/ingest/V1_IngestDefinition.js';
 import type { V1_PackageableElement } from '../../../model/packageableElements/V1_PackageableElement.js';
 import type { V1_AppDirNode } from '../../../lakehouse/entitlements/V1_CoreEntitlements.js';
 import { V1_AppDirNodeModelSchema } from './lakehouse/V1_CoreEntitlementsSerializationHelper.js';
@@ -28,9 +34,12 @@ import {
   createModelSchema,
   custom,
   deserialize,
+  list,
+  optional,
   primitive,
   serialize,
 } from 'serializr';
+import { V1_relationTypeColumnModelSchema } from './V1_TypeSerializationHelper.js';
 import {
   type V1_IngestEnvironment,
   V1_AWSSnowflakeIngestEnvironment,
@@ -167,3 +176,44 @@ export const V1_deserializeProducerEnvironment = (
       throw new Error(`Unknown V1_ProducerEnvironment type: ${json._type}`);
   }
 };
+
+// --------------------------------------------- Ingest Dataset Content ---------------------------------------------
+
+const V1_IngestDatasetSchemaModelSchema = createModelSchema(
+  V1_IngestDatasetSchema,
+  {
+    _type: primitive(),
+    columns: list(usingModelSchema(V1_relationTypeColumnModelSchema)),
+  },
+);
+
+const V1_IngestDatasetSourceModelSchema = createModelSchema(
+  V1_IngestDatasetSource,
+  {
+    _type: primitive(),
+    schema: usingModelSchema(V1_IngestDatasetSchemaModelSchema),
+  },
+);
+
+export const V1_IngestDatasetModelSchema = createModelSchema(V1_IngestDataset, {
+  name: primitive(),
+  primaryKey: list(primitive()),
+  source: usingModelSchema(V1_IngestDatasetSourceModelSchema),
+});
+
+export const V1_IngestDefinitionContentModelSchema = createModelSchema(
+  V1_IngestDefinitionContent,
+  {
+    datasets: optional(list(usingModelSchema(V1_IngestDatasetModelSchema))),
+  },
+);
+
+export const V1_deserializeIngestDefinitionContent = (
+  json: PlainObject<V1_IngestDefinitionContent>,
+): V1_IngestDefinitionContent =>
+  deserialize(V1_IngestDefinitionContentModelSchema, json);
+
+export const V1_serializeIngestDefinitionContent = (
+  content: V1_IngestDefinitionContent,
+): PlainObject<V1_IngestDefinitionContent> =>
+  serialize(V1_IngestDefinitionContentModelSchema, content);