@finos/legend-graph 32.3.2 → 32.3.3

package/src/graph/PureModel.ts

@@ -69,6 +69,7 @@ import type { PropertyOwner } from './metamodel/pure/packageableElements/domain/
 import type { ExecutionEnvironmentInstance } from './metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
 import { FunctionActivator } from './metamodel/pure/packageableElements/function/FunctionActivator.js';
 import type { IngestDefinition } from './metamodel/pure/packageableElements/ingest/IngestDefinition.js';
+import type { DataProduct } from './metamodel/pure/dataProduct/DataProduct.js';
 
 export interface GraphTextInputOption {
   graphGrammar: string | undefined;
@@ -510,6 +511,24 @@ export class PureModel extends BasicModel {
         this.coreModel.getOwnNullableStore(path),
       `Can't find store '${path}'`,
     );
+  getDataProduct = (path: string): DataProduct =>
+    guaranteeNonNullable(
+      this.getOwnNullableDataProduct(path) ??
+        this.generationModel.getOwnNullableDataProduct(path) ??
+        this.dependencyManager.getOwnNullableDataProduct(path) ??
+        this.systemModel.getOwnNullableDataProduct(path) ??
+        this.coreModel.getOwnNullableDataProduct(path),
+      `Can't find data product '${path}'`,
+    );
+  getIngestDefinition = (path: string): IngestDefinition =>
+    guaranteeNonNullable(
+      this.getOwnNullableIngestDefinition(path) ??
+        this.generationModel.getOwnNullableIngestDefinition(path) ??
+        this.dependencyManager.getOwnNullableIngestDefinition(path) ??
+        this.systemModel.getOwnNullableIngestDefinition(path) ??
+        this.coreModel.getOwnNullableIngestDefinition(path),
+      `Can't find ingest definition '${path}'`,
+    );
   getFlatDataStore = (path: string): FlatData =>
     guaranteeType(
       this.getStore(path),

package/src/graph/helpers/STO_Internal_Relational_Helper.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 { assertTrue, assertType, filterByType } from '@finos/legend-shared';
+import { Column } from '../metamodel/pure/packageableElements/store/relational/model/Column.js';
+import { Table } from '../metamodel/pure/packageableElements/store/relational/model/Table.js';
+import type { View } from '../metamodel/pure/packageableElements/store/relational/model/View.js';
+import type { Database } from '../../STO_Relational_Exports.js';
+import { INTERNAL__LakehouseGeneratedDatabase } from '../metamodel/pure/packageableElements/store/relational/model/Database.js';
+import { Schema } from '../metamodel/pure/packageableElements/store/relational/model/Schema.js';
+
+export const getOrCreateColumnFromGeneratedTable = (
+  columnName: string,
+  relation: Table | View,
+): Column => {
+  let column = relation.columns
+    .filter(filterByType(Column))
+    .find((col) => col.name === columnName);
+  if (!column) {
+    column = new Column();
+    column.name = columnName;
+    column.owner = relation;
+    relation.columns.push(column);
+  }
+  return column;
+};
+
+export const isGeneratedSchema = (schema: Schema): boolean => {
+  return schema._OWNER instanceof INTERNAL__LakehouseGeneratedDatabase;
+};
+
+export const isGeneratedRelation = (relation: Table | View): boolean => {
+  return isGeneratedSchema(relation.schema);
+};
+
+export const getOrCreateTableFromGeneratedSchema = (
+  tableName: string,
+  schema: Schema,
+): Table => {
+  assertTrue(isGeneratedSchema(schema), 'Schema must be generated');
+  let table = schema.tables.find((t) => t.name === tableName);
+  if (!table) {
+    table = new Table(tableName, schema);
+    schema.tables.push(table);
+  }
+  return table;
+};
+
+export const getOrCreateSchemaFromGeneratedDatabase = (
+  schemaName: string,
+  db: Database,
+): Schema => {
+  assertType(
+    db,
+    INTERNAL__LakehouseGeneratedDatabase,
+    'Database must be a generated database',
+  );
+  const schema = db.schemas.find((s) => s.name === schemaName);
+  if (schema) {
+    return schema;
+  }
+  const newSchema = new Schema(schemaName, db);
+  db.schemas.push(newSchema);
+  return newSchema;
+};
+
+export const findGeneratedDatabase = (
+  database: Database,
+  path: string,
+): INTERNAL__LakehouseGeneratedDatabase | undefined => {
+  return database.includedStoreSpecifications.find(
+    (x) => x.packageableElementPointer.value.path === path,
+  )?.generatedDatabase;
+};
+
+export const buildGeneratedIndex = (
+  database: Database,
+): Map<string, INTERNAL__LakehouseGeneratedDatabase> | undefined => {
+  const index = new Map<string, INTERNAL__LakehouseGeneratedDatabase>();
+  database.includedStoreSpecifications.forEach((inc) =>
+    index.set(inc.packageableElementPointer.value.path, inc.generatedDatabase),
+  );
+  return index.size > 0 ? index : undefined;
+};

package/src/graph/helpers/STO_Relational_Helper.ts

@@ -21,7 +21,10 @@ import {
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { Column } from '../metamodel/pure/packageableElements/store/relational/model/Column.js';
-import { Database } from '../metamodel/pure/packageableElements/store/relational/model/Database.js';
+import {
+  Database,
+  type INTERNAL__LakehouseGeneratedDatabase,
+} from '../metamodel/pure/packageableElements/store/relational/model/Database.js';
 import type { Filter } from '../metamodel/pure/packageableElements/store/relational/model/Filter.js';
 import type { Join } from '../metamodel/pure/packageableElements/store/relational/model/Join.js';
 import {
@@ -57,6 +60,10 @@ import {
 } from '../../STO_Relational_Exports.js';
 import type { PackageableElement } from '../metamodel/pure/packageableElements/PackageableElement.js';
 import { PackageableConnection } from '../metamodel/pure/packageableElements/connection/PackageableConnection.js';
+import {
+  getOrCreateColumnFromGeneratedTable,
+  isGeneratedRelation,
+} from './STO_Internal_Relational_Helper.js';
 
 const collectIncludedDatabases = (
   results: Set<Database>,
@@ -90,6 +97,16 @@ export const getAllIncludedDatabases = (db: Database): Set<Database> => {
   return results;
 };
 
+export const getAllIncludedGeneratedDatabases = (
+  db: Database,
+): Set<INTERNAL__LakehouseGeneratedDatabase> => {
+  return new Set(
+    db.includedStoreSpecifications.map(
+      (includedStore) => includedStore.generatedDatabase,
+    ),
+  );
+};
+
 export const getJoinType = (type: string): JoinType => {
   switch (type) {
     case JoinType.INNER:
@@ -167,7 +184,7 @@ export const getFilter = (database: Database, name: string): Filter =>
 export const getNullableTable = (
   schema: Schema,
   name: string,
-): Table | undefined => schema.tables.find((table) => table.name === name);
+): Table | undefined => schema.tables.find((_table) => _table.name === name);
 
 export const getTable = (schema: Schema, name: string): Table =>
   guaranteeNonNullable(
@@ -189,13 +206,17 @@ export const getRelation = (schema: Schema, name: string): Relation => {
   );
 };
 
-export const getColumn = (relation: Table | View, name: string): Column =>
-  guaranteeNonNullable(
-    relation.columns
-      .filter(filterByType(Column))
-      .find((column) => column.name === name),
-    `Can't find column '${name}' in table '${relation.name}'`,
-  );
+export function getColumn(relation: Table | View, name: string): Column {
+  if (!isGeneratedRelation(relation)) {
+    guaranteeNonNullable(
+      relation.columns
+        .filter(filterByType(Column))
+        .find((column) => column.name === name),
+      `Can't find column '${name}' in table '${relation.name}'`,
+    );
+  }
+  return getOrCreateColumnFromGeneratedTable(name, relation);
+}
 
 export const stringifyDataType = (type: RelationalDataType): string => {
   if (type instanceof VarChar) {

package/src/graph/metamodel/pure/data/EmbeddedData.ts

@@ -31,6 +31,7 @@ export interface EmbeddedDataVisitor<T> {
 
   visit_ExternalFormatData(data: ExternalFormatData): T;
   visit_ModelStoreData(data: ModelStoreData): T;
+  visit_RelationElementsData(data: RelationElementsData): T;
   visit_DataElementReference(data: DataElementReference): T;
   visit_RelationalCSVData(data: RelationalCSVData): T;
 }
@@ -121,3 +122,44 @@ export class ModelStoreData extends EmbeddedData implements Hashable {
     return visitor.visit_ModelStoreData(this);
   }
 }
+
+export class RelationRowTestData implements Hashable {
+  values!: string[];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATION_ROW_TEST_DATA,
+      hashArray(this.values),
+    ]);
+  }
+}
+
+export class RelationElement implements Hashable {
+  paths!: string[];
+  columns!: string[];
+  rows: RelationRowTestData[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATION_ELEMENT,
+      hashArray(this.paths),
+      hashArray(this.columns),
+      hashArray(this.rows),
+    ]);
+  }
+}
+
+export class RelationElementsData extends EmbeddedData implements Hashable {
+  relationElements: RelationElement[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATION_ELEMENTS_DATA,
+      hashArray(this.relationElements),
+    ]);
+  }
+
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_RelationElementsData(this);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/function/test/{FunctionStoreTestData.ts → FunctionTestData.ts}

@@ -17,19 +17,19 @@
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import type { PackageableElementReference } from '../../PackageableElementReference.js';
 import type { EmbeddedData } from '../../../data/EmbeddedData.js';
-import type { Store } from '../../store/Store.js';
 import { CORE_HASH_STRUCTURE } from '../../../../../Core_HashUtils.js';
+import type { PackageableElement } from '../../PackageableElement.js';
 
-export class FunctionStoreTestData implements Hashable {
+export class FunctionTestData implements Hashable {
   doc: string | undefined;
-  store!: PackageableElementReference<Store>;
+  element!: PackageableElementReference<PackageableElement>;
   data!: EmbeddedData;
 
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FUNCTION_STORE_TEST_DATA,
       this.doc ?? '',
-      this.store.valueForSerialization ?? '',
+      this.element.valueForSerialization ?? '',
       this.data,
     ]);
   }

package/src/graph/metamodel/pure/packageableElements/function/test/FunctionTestSuite.ts

@@ -16,11 +16,11 @@
 
 import { hashArray } from '@finos/legend-shared';
 import { TestSuite } from '../../../test/Test.js';
-import type { FunctionStoreTestData } from './FunctionStoreTestData.js';
+import type { FunctionTestData } from './FunctionTestData.js';
 import { CORE_HASH_STRUCTURE } from '../../../../../Core_HashUtils.js';
 
 export class FunctionTestSuite extends TestSuite {
-  testData: FunctionStoreTestData[] | undefined;
+  testData: FunctionTestData[] | undefined;
 
   override get hashCode(): string {
     return hashArray([

package/src/graph/metamodel/pure/packageableElements/runtime/Runtime.ts

@@ -83,10 +83,7 @@ export class ConnectionStores implements Hashable {
       this.connectionPointer,
       hashArray(
         this.storePointers.map((s) =>
-          hashElementPointer(
-            PackageableElementPointerType.STORE,
-            s.valueForSerialization ?? '',
-          ),
+          hashElementPointer(undefined, s.valueForSerialization ?? ''),
         ),
       ),
     ]);

package/src/graph/metamodel/pure/packageableElements/store/relational/model/Database.ts

@@ -21,11 +21,15 @@ import type { PackageableElementVisitor } from '../../../PackageableElement.js';
 import type { Schema } from './Schema.js';
 import type { Join } from './Join.js';
 import type { Filter } from './Filter.js';
+import type { IncludeStore } from './IncludeStore.js';
+import type { DataProduct } from '../../../../dataProduct/DataProduct.js';
+import type { IngestDefinition } from '../../../ingest/IngestDefinition.js';
 
 export class Database extends Store implements Hashable {
   schemas: Schema[] = [];
   joins: Join[] = [];
   filters: Filter[] = [];
+  includedStoreSpecifications: IncludeStore[] = [];
 
   protected override get _elementHashCode(): string {
     return hashArray([
@@ -39,6 +43,7 @@ export class Database extends Store implements Hashable {
       hashArray(this.filters),
       hashArray(this.stereotypes.map((val) => val.pointerHashCode)),
       hashArray(this.taggedValues),
+      hashArray(this.includedStoreSpecifications),
     ]);
   }
 
@@ -48,3 +53,25 @@ export class Database extends Store implements Hashable {
     return visitor.visit_Database(this);
   }
 }
+
+export class INTERNAL__LakehouseGeneratedDatabase extends Database {
+  readonly generatorElement: DataProduct | IngestDefinition;
+  readonly OWNER: Database;
+  constructor(
+    generatorElement: DataProduct | IngestDefinition,
+    owner: Database,
+  ) {
+    super(owner.name);
+    this.generatorElement = generatorElement;
+    this.OWNER = owner;
+  }
+  override accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_Database(this);
+  }
+
+  override get path(): string {
+    return `${this.generatorElement.path}`;
+  }
+}

package/src/graph/metamodel/pure/packageableElements/store/relational/model/IncludeStore.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2025-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 { hashArray, type Hashable } from '@finos/legend-shared';
+import type { PackageableElementReference } from '../../../PackageableElementReference.js';
+import type { IngestDefinition } from '../../../ingest/IngestDefinition.js';
+import type { DataProduct } from '../../../../dataProduct/DataProduct.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.js';
+import type { INTERNAL__LakehouseGeneratedDatabase } from './Database.js';
+
+export class IncludeStore implements Hashable {
+  packageableElementPointer: PackageableElementReference<
+    IngestDefinition | DataProduct
+  >;
+  storeType: string;
+  generatedDatabase!: INTERNAL__LakehouseGeneratedDatabase;
+
+  constructor(
+    packageableElementPointer: PackageableElementReference<
+      IngestDefinition | DataProduct
+    >,
+    storeType: string,
+  ) {
+    this.packageableElementPointer = packageableElementPointer;
+    this.storeType = storeType;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATABASE_INCLUDE_STORE,
+      this.packageableElementPointer.value.path,
+      this.storeType,
+    ]);
+  }
+}

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

@@ -85,7 +85,7 @@ import {
   observe_AtomicTest,
   observe_TestAssertion,
 } from './Testable_ObserverHelper.js';
-import type { FunctionStoreTestData } from '../../../graph/metamodel/pure/packageableElements/function/test/FunctionStoreTestData.js';
+import type { FunctionTestData } from '../../../graph/metamodel/pure/packageableElements/function/test/FunctionTestData.js';
 import { observe_EmbeddedData } from './DSL_Data_ObserverHelper.js';
 import type { HostedService } from '../../../graph/metamodel/pure/packageableElements/function/HostedService.js';
 import type { MemSQLFunction } from '../../../graph/metamodel/pure/packageableElements/function/MemSQLFunction.js';
@@ -499,9 +499,9 @@ export const observe_FunctionTest = skipObserved(
 );
 
 export const observe_FunctionTestData = skipObservedWithContext(
-  (metamodel: FunctionStoreTestData, context: ObserverContext) => {
+  (metamodel: FunctionTestData, context: ObserverContext) => {
     makeObservable(metamodel, {
-      store: observable,
+      element: observable,
       data: observable,
       hashCode: computed,
     });

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

@@ -369,6 +369,7 @@ import {
   V1_LineageInput,
   type V1_RawLineageModel,
 } from './model/lineage/V1_Lineage.js';
+import { V1_IngestDefinition } from './model/packageableElements/ingest/V1_IngestDefinition.js';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -4587,6 +4588,9 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       protocol instanceof V1_INTERNAL__UnknownFunctionActivator ||
       protocol instanceof V1_INTERNAL__UnknownStore
     ) {
+      if (protocol instanceof V1_IngestDefinition) {
+        return CORE_PURE_PATH.INGEST_DEFINITION;
+      }
       const _type = protocol.content._type;
       const classifierPath = isString(_type)
         ? this.elementClassifierPathMap.get(_type)

package/src/graph-manager/protocol/pure/v1/model/data/V1_EmbeddedData.ts

@@ -31,6 +31,7 @@ export interface V1_EmbeddedDataVisitor<T> {
 
   visit_ExternalFormatData(data: V1_ExternalFormatData): T;
   visit_ModelStoreData(data: V1_ModelStoreData): T;
+  visit_RelationElementsData(data: V1_RelationElementsData): T;
   visit_DataElementReference(data: V1_DataElementReference): T;
   visit_RelationalData(data: V1_RelationalCSVData): T;
 }
@@ -125,3 +126,47 @@ export class V1_ModelStoreData extends V1_EmbeddedData implements Hashable {
     return visitor.visit_ModelStoreData(this);
   }
 }
+
+export class V1_RelationRowTestData implements Hashable {
+  values!: string[];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATION_ROW_TEST_DATA,
+      hashArray(this.values),
+    ]);
+  }
+}
+
+export class V1_RelationElement implements Hashable {
+  paths!: string[];
+  columns!: string[];
+  rows: V1_RelationRowTestData[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATION_ELEMENT,
+      hashArray(this.paths),
+      hashArray(this.columns),
+      hashArray(this.rows),
+    ]);
+  }
+}
+
+export class V1_RelationElementsData
+  extends V1_EmbeddedData
+  implements Hashable
+{
+  relationElements: V1_RelationElement[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATION_ELEMENTS_DATA,
+      hashArray(this.relationElements),
+    ]);
+  }
+
+  accept_EmbeddedDataVisitor<T>(visitor: V1_EmbeddedDataVisitor<T>): T {
+    return visitor.visit_RelationElementsData(this);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/test/{V1_FunctionStoreTestData.ts → V1_FunctionTestData.ts}

@@ -19,16 +19,16 @@ import type { V1_EmbeddedData } from '../../../data/V1_EmbeddedData.js';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../../graph/Core_HashUtils.js';
 import type { V1_PackageableElementPointer } from '../../V1_PackageableElement.js';
 
-export class V1_FunctionStoreTestData implements Hashable {
+export class V1_FunctionTestData implements Hashable {
   doc: string | undefined;
-  store!: V1_PackageableElementPointer;
+  packageableElementPointer!: V1_PackageableElementPointer;
   data!: V1_EmbeddedData;
 
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FUNCTION_STORE_TEST_DATA,
       this.doc ?? '',
-      this.store.path,
+      this.packageableElementPointer.path,
       this.data,
     ]);
   }

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/test/V1_FunctionTestSuite.ts

@@ -17,10 +17,10 @@
 import { hashArray } from '@finos/legend-shared';
 import { V1_TestSuite } from '../../../test/V1_TestSuite.js';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../../graph/Core_HashUtils.js';
-import type { V1_FunctionStoreTestData } from './V1_FunctionStoreTestData.js';
+import type { V1_FunctionTestData } from './V1_FunctionTestData.js';
 
 export class V1_FunctionTestSuite extends V1_TestSuite {
-  testData: V1_FunctionStoreTestData[] | undefined;
+  testData: V1_FunctionTestData[] | undefined;
 
   override get hashCode(): string {
     return hashArray([

package/src/graph-manager/protocol/pure/v1/model/packageableElements/store/relational/model/V1_Database.ts

@@ -23,6 +23,7 @@ import type { V1_Join } from './V1_Join.js';
 import type { V1_Filter } from './V1_Filter.js';
 import type { V1_StereotypePtr } from '../../../domain/V1_StereotypePtr.js';
 import type { V1_TaggedValue } from '../../../domain/V1_TaggedValue.js';
+import type { V1_IncludeStore } from './V1_IncludeStore.js';
 
 export class V1_Database extends V1_Store implements Hashable {
   schemas: V1_Schema[] = [];
@@ -30,6 +31,7 @@ export class V1_Database extends V1_Store implements Hashable {
   filters: V1_Filter[] = [];
   stereotypes: V1_StereotypePtr[] = [];
   taggedValues: V1_TaggedValue[] = [];
+  includedStoreSpecifications: V1_IncludeStore[] = [];
 
   override get hashCode(): string {
     return hashArray([
@@ -41,6 +43,7 @@ export class V1_Database extends V1_Store implements Hashable {
       hashArray(this.filters),
       hashArray(this.stereotypes),
       hashArray(this.taggedValues),
+      hashArray(this.includedStoreSpecifications),
     ]);
   }
 

package/src/graph-manager/protocol/pure/v1/model/packageableElements/store/relational/model/V1_IncludeStore.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2025-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 Hashable, hashArray } from '@finos/legend-shared';
+import { type V1_PackageableElementPointer } from '../../../../../model/packageableElements/V1_PackageableElement.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../../../graph/Core_HashUtils.js';
+
+export class V1_IncludeStore implements Hashable {
+  packageableElementPointer!: V1_PackageableElementPointer;
+  storeType!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATABASE_INCLUDE_STORE,
+      this.packageableElementPointer.path,
+      this.storeType,
+    ]);
+  }
+}

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

@@ -26,7 +26,7 @@ import {
 export const V1_transformElementReferencePointer = <
   T extends PackageableElement,
 >(
-  pointerType: string,
+  pointerType: string | undefined,
   ref: PackageableElementReference<T>,
 ): V1_PackageableElementPointer =>
   new V1_PackageableElementPointer(