@finos/legend-graph 32.4.3 → 32.5.1

package/src/graph-manager/helpers/DataProductHelper.ts

@@ -27,6 +27,8 @@ import {
   type DataProductElement,
   type ElementScope,
   type NativeModelExecutionContext,
+  LakehouseAccessPoint,
+  type AccessPointGroup,
 } from '../../graph/metamodel/pure/dataProduct/DataProduct.js';
 import type { Mapping } from '../../graph/metamodel/pure/packageableElements/mapping/Mapping.js';
 import type { GraphManagerState } from '../GraphManagerState.js';
@@ -119,9 +121,26 @@ export const resolveUsableDataProductClasses = (
   return compatibleClasses;
 };
 
+export const resolveLakehouseAccessPoint = (
+  dataProduct: DataProduct,
+): LakehouseAccessPoint | undefined => {
+  for (const group of dataProduct.accessPointGroups) {
+    const lakehouseAp = group.accessPoints.find(
+      (ap): ap is LakehouseAccessPoint => ap instanceof LakehouseAccessPoint,
+    );
+    if (lakehouseAp) {
+      return lakehouseAp;
+    }
+  }
+  return undefined;
+};
+
 export const resolveDataProductExecutionState = (
   dataProduct: DataProduct,
-): NativeModelExecutionContext | ModelAccessPointGroup => {
+):
+  | NativeModelExecutionContext
+  | ModelAccessPointGroup
+  | LakehouseAccessPoint => {
   if (isDataProductNative(dataProduct)) {
     return getModelGroupFromNativeDataProduct(dataProduct)
       .defaultExecutionContext;
@@ -129,9 +148,33 @@ export const resolveDataProductExecutionState = (
     const modelAccessGroup = dataProduct.accessPointGroups.filter(
       filterByType(ModelAccessPointGroup),
     )[0];
-    return guaranteeNonNullable(
-      modelAccessGroup,
-      'No native model access group or model access group on data product',
+    if (modelAccessGroup) {
+      return modelAccessGroup;
+    }
+    const lakehouseAccessPoint = resolveLakehouseAccessPoint(dataProduct);
+    if (lakehouseAccessPoint) {
+      return lakehouseAccessPoint;
+    }
+    throw new Error(
+      'No native model access, model access group, or lakehouse access point on data product',
     );
   }
 };
+
+export const findLakehouseAccessPointGroup = (
+  dataProduct: DataProduct,
+  accessPointId: string,
+):
+  | { group: AccessPointGroup; accessPoint: LakehouseAccessPoint }
+  | undefined => {
+  for (const group of dataProduct.accessPointGroups) {
+    const ap = group.accessPoints.find(
+      (a): a is LakehouseAccessPoint =>
+        a instanceof LakehouseAccessPoint && a.id === accessPointId,
+    );
+    if (ap) {
+      return { group, accessPoint: ap };
+    }
+  }
+  return undefined;
+};

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

@@ -398,6 +398,10 @@ import {
   V1_MetadatProject,
 } from './engine/dev-metadata/V1_DevMetadataPushRequest.js';
 import type { MetadataRequestOptions } from '../../../action/dev-metadata/MetadataRequestOptions.js';
+import type { Accessor } from '../../../../graph/metamodel/pure/packageableElements/relation/Accessor.js';
+import { IngestDefinition } from '../../../../graph/metamodel/pure/packageableElements/ingest/IngestDefinition.js';
+import { Database } from '../../../../graph/metamodel/pure/packageableElements/store/relational/model/Database.js';
+import { V1_createAccessorFromPackageableElement } from './helpers/V1_AccessorHelper.js';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -2232,6 +2236,31 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     }
   }
 
+  //
+
+  override createAccessorFromPackageableElement(
+    element: PackageableElement,
+    graph: PureModel,
+    options?: {
+      schemaName?: string | undefined;
+      tableName?: string | undefined;
+    },
+  ): Accessor | undefined {
+    if (
+      !(element instanceof IngestDefinition) &&
+      !(element instanceof Database)
+    ) {
+      return undefined;
+    }
+    const context = new V1_GraphBuilderContextBuilder(
+      graph,
+      graph,
+      this.graphBuilderExtensions,
+      this.logService,
+    ).build();
+    return V1_createAccessorFromPackageableElement(element, context, options);
+  }
+
   private buildLambdaReturnTypeInput(
     lambda: RawLambda,
     graph: PureModel,
@@ -3541,12 +3570,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       packageName: string;
       pattern: string;
       serviceOwners: string[];
+      title?: string | undefined;
     },
     graph: Entity[],
   ): Promise<Entity> {
     const service = new V1_Service();
     service.name = serviceConfig.name;
     service.package = serviceConfig.packageName;
+    service.title = serviceConfig.title;
     const owernship = new V1_UserListOwnership();
     owernship.users = serviceConfig.serviceOwners;
     service.ownership = owernship;

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

@@ -36,6 +36,8 @@ import {
   QueryDataProductModelAccessExecutionContext,
   QueryDataProductNativeExecutionContextInfo,
   QueryDataProductModelAccessExecutionContextInfo,
+  QueryDataProductLakehouseExecutionContext,
+  QueryDataProductLakehouseExecutionContextInfo,
 } from '../../../../../graph-manager/action/query/Query.js';
 import {
   type V1_LightQuery,
@@ -46,6 +48,7 @@ import {
   type V1_QueryExecutionContext,
   V1_DataProductNativeExecutionContext,
   V1_DataProductModelAccessExecutionContext,
+  V1_DataProductLakehouseExecutionContext,
 } from './query/V1_Query.js';
 import type { PureModel } from '../../../../../graph/PureModel.js';
 import { DEPRECATED__ServiceTestResult } from '../../../../../graph-manager/action/service/DEPRECATED__ServiceTestResult.js';
@@ -220,6 +223,13 @@ export const V1_buildExecutionContext = (
     exec.dataProductPath = protocolExecContext.dataProductPath;
     exec.accessPointGroupId = protocolExecContext.accessPointGroupId;
     return exec;
+  } else if (
+    protocolExecContext instanceof V1_DataProductLakehouseExecutionContext
+  ) {
+    const exec = new QueryDataProductLakehouseExecutionContext();
+    exec.dataProductPath = protocolExecContext.dataProductPath;
+    exec.accessPointId = protocolExecContext.accessPointId;
+    return exec;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
 };
@@ -263,6 +273,13 @@ export const V1_buildExecutionContextInfo = (
     exec.dataProductPath = v1_execContext.dataProductPath;
     exec.accessPointGroupId = v1_execContext.accessPointGroupId;
     return exec;
+  } else if (
+    v1_execContext instanceof V1_DataProductLakehouseExecutionContext
+  ) {
+    const exec = new QueryDataProductLakehouseExecutionContextInfo();
+    exec.dataProductPath = v1_execContext.dataProductPath;
+    exec.accessPointId = v1_execContext.accessPointId;
+    return exec;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
 };
@@ -382,6 +399,11 @@ export const V1_transformQueryExecutionContext = (
     protocol.dataProductPath = execContext.dataProductPath;
     protocol.accessPointGroupId = execContext.accessPointGroupId;
     return protocol;
+  } else if (execContext instanceof QueryDataProductLakehouseExecutionContext) {
+    const protocol = new V1_DataProductLakehouseExecutionContext();
+    protocol.dataProductPath = execContext.dataProductPath;
+    protocol.accessPointId = execContext.accessPointId;
+    return protocol;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
 };

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

@@ -67,6 +67,7 @@ export enum V1_QueryExecutionContextType {
   QUERY_DATASAPCE_EXECUTION_CONTEXT = 'dataSpaceExecutionContext',
   QUERY_DATAPRODUCT_NATIVE_EXECUTION_CONTEXT = 'dataProductNativeExecutionContext',
   QUERY_DATAPRODUCT_MODEL_ACCESS_EXECUTION_CONTEXT = 'dataProductModelAccessExecutionContext',
+  QUERY_DATAPRODUCT_LAKEHOUSE_EXECUTION_CONTEXT = 'dataProductLakehouseExecutionContext',
 }
 
 export class V1_QueryExplicitExecutionContext extends V1_QueryExecutionContext {
@@ -143,6 +144,23 @@ export class V1_DataProductModelAccessExecutionContext extends V1_QueryDataProdu
   );
 }
 
+export class V1_DataProductLakehouseExecutionContext extends V1_QueryDataProductExecutionContext {
+  accessPointId!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataProductLakehouseExecutionContext, {
+      _type: usingConstantValueSchema(
+        V1_QueryExecutionContextType.QUERY_DATAPRODUCT_LAKEHOUSE_EXECUTION_CONTEXT,
+      ),
+      dataProductPath: primitive(),
+      accessPointId: primitive(),
+    }),
+    {
+      deserializeNullAsUndefined: true,
+    },
+  );
+}
+
 export const V1_deserializeQueryExecutionContext = (
   json: PlainObject<V1_QueryExecutionContext>,
 ): V1_QueryExecutionContext => {
@@ -167,6 +185,11 @@ export const V1_deserializeQueryExecutionContext = (
         V1_DataProductModelAccessExecutionContext.serialization.schema,
         json,
       );
+    case V1_QueryExecutionContextType.QUERY_DATAPRODUCT_LAKEHOUSE_EXECUTION_CONTEXT:
+      return deserialize(
+        V1_DataProductLakehouseExecutionContext.serialization.schema,
+        json,
+      );
     default: {
       throw new UnsupportedOperationError(
         `Can't deserialize authentication strategy of type '${json._type}': no compatible deserializer available from plugins`,
@@ -198,6 +221,11 @@ export const V1_serializeQueryExecutionContext = (
       V1_DataProductModelAccessExecutionContext.serialization.schema,
       protocol,
     );
+  } else if (protocol instanceof V1_DataProductLakehouseExecutionContext) {
+    return serialize(
+      V1_DataProductLakehouseExecutionContext.serialization.schema,
+      protocol,
+    );
   }
   throw new UnsupportedOperationError(
     `Can't serialize authentication strategy: no compatible serializer available from plugins`,

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;