@finos/legend-graph 11.0.0 → 12.0.0

package/src/graph/helpers/StoreFlatData_Helper.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { guaranteeNonNullable } from '@finos/legend-shared';
+import type { FlatData } from '../metamodel/pure/packageableElements/store/flatData/model/FlatData.js';
+import type { RootFlatDataRecordType } from '../metamodel/pure/packageableElements/store/flatData/model/FlatDataDataType.js';
+import type { FlatDataSection } from '../metamodel/pure/packageableElements/store/flatData/model/FlatDataSection.js';
+
+export const getRootRecordType = (
+  section: FlatDataSection,
+): RootFlatDataRecordType =>
+  guaranteeNonNullable(
+    section.recordType,
+    `No record type defined in section '${section.name}' of flat-data store '${section._OWNER.path}'`,
+  );
+
+export const getSection = (flatData: FlatData, name: string): FlatDataSection =>
+  guaranteeNonNullable(
+    flatData.sections.find((section) => section.name === name),
+    `Can't find section '${name}' in flat-data store '${flatData.path}'`,
+  );
+
+export const getAllRecordTypes = (
+  flatData: FlatData,
+): RootFlatDataRecordType[] =>
+  flatData.sections.flatMap((section) =>
+    section.recordType ? [section.recordType] : [],
+  );

package/src/graph/helpers/StoreRelational_Helper.ts

@@ -0,0 +1,161 @@
+/**
+ * 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 {
+  filterByType,
+  guaranteeNonNullable,
+  guaranteeType,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { RelationalInputType } from '../metamodel/pure/packageableElements/store/relational/mapping/RelationalInputData.js';
+import { Column } from '../metamodel/pure/packageableElements/store/relational/model/Column.js';
+import { Database } 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 {
+  JoinType,
+  type Relation,
+} from '../metamodel/pure/packageableElements/store/relational/model/RelationalOperationElement.js';
+import type { Schema } from '../metamodel/pure/packageableElements/store/relational/model/Schema.js';
+import type { Table } from '../metamodel/pure/packageableElements/store/relational/model/Table.js';
+import type { View } from '../metamodel/pure/packageableElements/store/relational/model/View.js';
+
+const collectIncludedDatabases = (
+  results: Set<Database>,
+  databases: Database[],
+): void => {
+  databases.forEach((i) => {
+    const includedDb = guaranteeType(i, Database);
+    if (!results.has(includedDb)) {
+      results.add(includedDb);
+      collectIncludedDatabases(
+        results,
+        includedDb.includes.map((s) => guaranteeType(s.value, Database)),
+      );
+    }
+  });
+};
+
+export const getAllIncludedDatabases = (db: Database): Set<Database> => {
+  const includes = db.includes;
+  const results = new Set<Database>();
+  results.add(db);
+  if (!includes.length) {
+    return results;
+  }
+  collectIncludedDatabases(
+    results,
+    db.includes.map((includedStore) =>
+      guaranteeType(includedStore.value, Database),
+    ),
+  );
+  return results;
+};
+
+export const getJoinType = (type: string): JoinType => {
+  switch (type) {
+    case JoinType.INNER:
+      return JoinType.INNER;
+    case JoinType.LEFT_OUTER:
+      return JoinType.LEFT_OUTER;
+    case JoinType.RIGHT_OUTER:
+      return JoinType.RIGHT_OUTER;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported join type '${type}'`,
+      );
+  }
+};
+
+export const getRelationalInputType = (type: string): RelationalInputType => {
+  switch (type) {
+    case RelationalInputType.SQL:
+      return RelationalInputType.SQL;
+    case RelationalInputType.CSV:
+      return RelationalInputType.CSV;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported relational input type '${type}'`,
+      );
+  }
+};
+
+export const getNullableSchema = (
+  database: Database,
+  name: string,
+): Schema | undefined =>
+  database.schemas.find((schema) => schema.name === name);
+
+export const getNullableFilter = (
+  database: Database,
+  name: string,
+): Filter | undefined =>
+  Array.from(getAllIncludedDatabases(database))
+    .flatMap((includedDB) => includedDB.filters)
+    .find((filter) => filter.name === name);
+
+export const getSchema = (database: Database, name: string): Schema =>
+  guaranteeNonNullable(
+    getNullableSchema(database, name),
+    `Can't find schema '${name}' in database '${database.path}'`,
+  );
+
+export const getJoin = (database: Database, name: string): Join =>
+  guaranteeNonNullable(
+    Array.from(getAllIncludedDatabases(database))
+      .flatMap((includedDB) => includedDB.joins)
+      .find((join) => join.name === name),
+    `Can't find join '${name}' in database '${database.path}'`,
+  );
+
+export const getFilter = (database: Database, name: string): Filter =>
+  guaranteeNonNullable(
+    getNullableFilter(database, name),
+    `Can't find filter '${name}' in database '${database.path}'`,
+  );
+
+export const getNullableTable = (
+  schema: Schema,
+  name: string,
+): Table | undefined => schema.tables.find((table) => table.name === name);
+
+export const getTable = (schema: Schema, name: string): Table =>
+  guaranteeNonNullable(
+    getNullableTable(schema, name),
+    `Can't find table '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+
+export const getView = (schema: Schema, name: string): View =>
+  guaranteeNonNullable(
+    schema.views.find((view) => view.name === name),
+    `Can't find view '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+
+export const getRelation = (schema: Schema, name: string): Relation => {
+  const relations: (Table | View)[] = schema.tables;
+  return guaranteeNonNullable(
+    relations.concat(schema.views).find((relation) => relation.name === name),
+    `Can't find relation '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+};
+
+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}'`,
+  );

package/src/graph/helpers/ValueSpecificationHelper.ts

@@ -0,0 +1,139 @@
+/**
+ * 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 { Randomizer } from '@finos/legend-shared';
+import type { PureModel } from '../PureModel.js';
+import {
+  DATE_FORMAT,
+  DATE_TIME_FORMAT,
+  PRIMITIVE_TYPE,
+  TYPICAL_MULTIPLICITY_TYPE,
+} from '../MetaModelConst.js';
+import { Enumeration } from '../metamodel/pure/packageableElements/domain/Enumeration.js';
+import { EnumValueExplicitReference } from '../metamodel/pure/packageableElements/domain/EnumValueReference.js';
+import { GenericType } from '../metamodel/pure/packageableElements/domain/GenericType.js';
+import { GenericTypeExplicitReference } from '../metamodel/pure/packageableElements/domain/GenericTypeReference.js';
+import { PrimitiveType } from '../metamodel/pure/packageableElements/domain/PrimitiveType.js';
+import {
+  type InstanceValue,
+  CollectionInstanceValue,
+  EnumValueInstanceValue,
+  PrimitiveInstanceValue,
+} from '../metamodel/pure/valueSpecification/InstanceValue.js';
+import type { VariableExpression } from '../metamodel/pure/valueSpecification/VariableExpression.js';
+import { getEnumValue } from './DomainHelper.js';
+import { format, addDays } from 'date-fns';
+
+export const buildPrimitiveInstanceValue = (
+  graph: PureModel,
+  type: PRIMITIVE_TYPE,
+  value: unknown,
+): PrimitiveInstanceValue => {
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const instance = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(
+      new GenericType(graph.getPrimitiveType(type)),
+    ),
+    multiplicityOne,
+  );
+  instance.values = [value];
+  return instance;
+};
+
+const createMockPrimitiveProperty = (
+  primitiveType: PrimitiveType,
+  propertyName: string,
+): string | number | boolean => {
+  const randomizer = new Randomizer();
+  switch (primitiveType.name) {
+    case PRIMITIVE_TYPE.BOOLEAN:
+      return randomizer.getRandomItemInCollection([true, false]) ?? true;
+    case PRIMITIVE_TYPE.FLOAT:
+      return randomizer.getRandomFloat();
+    case PRIMITIVE_TYPE.DECIMAL:
+      return randomizer.getRandomDouble();
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.INTEGER:
+      return randomizer.getRandomWholeNumber(100);
+    // NOTE that `Date` is the umbrella type that comprises `StrictDate` and `DateTime`, but for simplicity, we will generate `Date` as `StrictDate`
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return format(
+        randomizer.getRandomDate(
+          new Date(Date.now()),
+          addDays(Date.now(), 100),
+        ),
+        DATE_FORMAT,
+      );
+    case PRIMITIVE_TYPE.DATETIME:
+      return format(
+        randomizer.getRandomDate(
+          new Date(Date.now()),
+          addDays(Date.now(), 100),
+        ),
+        DATE_TIME_FORMAT,
+      );
+    case PRIMITIVE_TYPE.STRING:
+    default:
+      return `${propertyName} ${randomizer.getRandomWholeNumber(100)}`;
+  }
+};
+
+export const createMockEnumerationProperty = (
+  enumeration: Enumeration,
+): string =>
+  new Randomizer().getRandomItemInCollection(enumeration.values)?.name ?? '';
+
+export const generateVariableExpressionMockValue = (
+  parameter: VariableExpression,
+): InstanceValue | undefined => {
+  const varType = parameter.genericType?.value.rawType;
+  const multiplicity = parameter.multiplicity;
+  if ((!multiplicity.upperBound || multiplicity.upperBound > 1) && varType) {
+    return new CollectionInstanceValue(
+      multiplicity,
+      GenericTypeExplicitReference.create(new GenericType(varType)),
+    );
+  }
+  if (varType instanceof PrimitiveType) {
+    const primitiveInst = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(new GenericType(varType)),
+      multiplicity,
+    );
+    primitiveInst.values = [
+      createMockPrimitiveProperty(
+        varType,
+        parameter.name === '' ? 'myVar' : parameter.name,
+      ),
+    ];
+    return primitiveInst;
+  } else if (varType instanceof Enumeration) {
+    const enumValueInstance = new EnumValueInstanceValue(
+      GenericTypeExplicitReference.create(new GenericType(varType)),
+      multiplicity,
+    );
+    const mock = createMockEnumerationProperty(varType);
+    if (mock !== '') {
+      enumValueInstance.values = [
+        EnumValueExplicitReference.create(getEnumValue(varType, mock)),
+      ];
+    }
+    return enumValueInstance;
+  }
+  return undefined;
+};

package/src/graph/helpers/creator/DSLExternalFormat_ModelCreatorHelper.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { ExternalFormatData } from '../../metamodel/pure/data/EmbeddedData.js';
+
+export const isStubbed_ExternalFormatData = (
+  value: ExternalFormatData,
+): boolean => value.data === '';

package/src/graph/helpers/creator/DSLMapping_ModelCreatorHelper.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 { isNonNullable } from '@finos/legend-shared';
+import { PackageableRuntime } from '../../../DSLMapping_Exports.js';
+import type { EnumValueMapping } from '../../metamodel/pure/packageableElements/mapping/EnumValueMapping.js';
+import { Mapping } from '../../metamodel/pure/packageableElements/mapping/Mapping.js';
+import type { SetImplementationContainer } from '../../metamodel/pure/packageableElements/mapping/SetImplementationContainer.js';
+import type { StoreConnections } from '../../metamodel/pure/packageableElements/runtime/Runtime.js';
+
+export const stub_Mapping = (): Mapping => new Mapping('');
+
+export const isStubbed_EnumValueMapping = (value: EnumValueMapping): boolean =>
+  !value.sourceValues.filter((sourceValue) => isNonNullable(sourceValue.value))
+    .length;
+
+export const isStubbed_StoreConnections = (value: StoreConnections): boolean =>
+  !value.storeConnections.length;
+
+export const isStubbed_SetImplementationContainer = (
+  value: SetImplementationContainer,
+): boolean => !value.setImplementation.value.id.value;
+
+export const stub_PackageableRuntime = (): PackageableRuntime =>
+  new PackageableRuntime('');

package/src/graph/helpers/creator/DomainModelCreatorHelper.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { Profile } from '../../metamodel/pure/packageableElements/domain/Profile.js';
+import { Tag } from '../../metamodel/pure/packageableElements/domain/Tag.js';
+import { Enum } from '../../metamodel/pure/packageableElements/domain/Enum.js';
+import { Stereotype } from '../../metamodel/pure/packageableElements/domain/Stereotype.js';
+import { TaggedValue } from '../../metamodel/pure/packageableElements/domain/TaggedValue.js';
+import { TagExplicitReference } from '../../metamodel/pure/packageableElements/domain/TagReference.js';
+import type { Enumeration } from '../../metamodel/pure/packageableElements/domain/Enumeration.js';
+import { Class } from '../../metamodel/pure/packageableElements/domain/Class.js';
+import { Constraint } from '../../metamodel/pure/packageableElements/domain/Constraint.js';
+import { stub_RawLambda } from './RawValueSpecificationCreatorHelper.js';
+import type { PackageableElement } from '../../metamodel/pure/packageableElements/PackageableElement.js';
+import { Multiplicity } from '../../metamodel/pure/packageableElements/domain/Multiplicity.js';
+import { GenericTypeExplicitReference } from '../../metamodel/pure/packageableElements/domain/GenericTypeReference.js';
+import { GenericType } from '../../metamodel/pure/packageableElements/domain/GenericType.js';
+import type { Type } from '../../metamodel/pure/packageableElements/domain/Type.js';
+import { DerivedProperty } from '../../metamodel/pure/packageableElements/domain/DerivedProperty.js';
+import { Property } from '../../metamodel/pure/packageableElements/domain/Property.js';
+
+export const stub_Tag = (profile: Profile): Tag => new Tag(profile, '');
+export const stub_TaggedValue = (tag: Tag): TaggedValue =>
+  new TaggedValue(TagExplicitReference.create(tag), '');
+export const stub_Stereotype = (profile: Profile): Stereotype =>
+  new Stereotype(profile, '');
+export const stub_Profile = (): Profile => new Profile('');
+export const stub_Enum = (enumeration: Enumeration): Enum =>
+  new Enum('', enumeration);
+export const stub_Constraint = (_class: Class): Constraint =>
+  new Constraint('', _class, stub_RawLambda());
+export const stub_Class = (): Class => new Class('');
+export const stub_Property = (type: Type, _class: Class): Property =>
+  new Property(
+    '',
+    // NOTE: this multiplicity is subjected to change so we cannot pass
+    // the one from the graph typical multiplicity index
+    new Multiplicity(1, 1),
+    GenericTypeExplicitReference.create(new GenericType(type)),
+    _class,
+  );
+export const stub_DerivedProperty = (
+  type: Type,
+  _class: Class,
+): DerivedProperty =>
+  new DerivedProperty(
+    '',
+    // NOTE: this multiplicity is subjected to change so we cannot pass
+    // the one from the graph typical multiplicity index
+    new Multiplicity(1, 1),
+    GenericTypeExplicitReference.create(new GenericType(type)),
+    _class,
+  );
+
+export const isStubbed_PackageableElement = (
+  element: PackageableElement,
+): boolean => !element.package && !element.name;

package/src/graph/helpers/creator/RawValueSpecificationCreatorHelper.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { Multiplicity } from '../../metamodel/pure/packageableElements/domain/Multiplicity.js';
+import type { Type } from '../../metamodel/pure/packageableElements/domain/Type.js';
+import { PackageableElementExplicitReference } from '../../metamodel/pure/packageableElements/PackageableElementReference.js';
+import { RawLambda } from '../../metamodel/pure/rawValueSpecification/RawLambda.js';
+import { RawVariableExpression } from '../../metamodel/pure/rawValueSpecification/RawVariableExpression.js';
+
+export const stub_RawVariableExpression = (type: Type): RawVariableExpression =>
+  new RawVariableExpression(
+    '',
+    // NOTE: this multiplicity is subjected to change so we cannot pass
+    // the one from the graph typical multiplicity index
+    new Multiplicity(1, 1),
+    PackageableElementExplicitReference.create(type),
+  );
+
+export const stub_RawLambda = (): RawLambda =>
+  new RawLambda(undefined, undefined);
+
+export const create_RawLambda = (
+  parameters: object | undefined,
+  body: object | undefined,
+): RawLambda => new RawLambda(parameters, body);
+
+export const isStubbed_RawLambda = (rawLambda: RawLambda): boolean =>
+  !rawLambda.body && !rawLambda.parameters;

package/src/graph/helpers/creator/StoreRelational_ModelCreatorHelper.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { isEmpty } from '@finos/legend-shared';
+import type { RawRelationalOperationElement } from '../../metamodel/pure/packageableElements/store/relational/model/RawRelationalOperationElement.js';
+import { Database } from '../../../StoreRelational_Exports.js';
+
+export const stub_RawRelationalOperationElement =
+  (): RawRelationalOperationElement => ({});
+
+export const isStubbed_RawRelationalOperationElement = (
+  operation: RawRelationalOperationElement,
+): boolean => isEmpty(operation);
+
+export const stub_Database = (): Database => new Database('');

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

@@ -0,0 +1,91 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../graph/Core_HashUtils.js';
+import type { DataElement } from '../packageableElements/data/DataElement.js';
+import type { Class } from '../packageableElements/domain/Class.js';
+import type { PackageableElementReference } from '../packageableElements/PackageableElementReference.js';
+import type { RelationalCSVData } from './RelationalCSVData.js';
+
+export interface EmbeddedDataVisitor<T> {
+  visit_EmbeddedData(embeddedData: EmbeddedData): T;
+  visit_ExternalFormatData(externalFormatData: ExternalFormatData): T;
+  visit_ModelStoreData(modelStoreData: ModelStoreData): T;
+  visit_DataElementReference(dataElementReference: DataElementReference): T;
+  visit_RelationalCSVData(relationalData: RelationalCSVData): T;
+}
+
+export abstract class EmbeddedData implements Hashable {
+  abstract get hashCode(): string;
+  abstract accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T;
+}
+
+export class DataElementReference extends EmbeddedData implements Hashable {
+  dataElement!: PackageableElementReference<DataElement>;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_ELEMENT_REFERENCE,
+      this.dataElement.valueForSerialization ?? '',
+    ]);
+  }
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_DataElementReference(this);
+  }
+}
+
+export class ExternalFormatData extends EmbeddedData implements Hashable {
+  contentType!: string;
+  data!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EXTERNAL_FORMAT_DATA,
+      this.contentType,
+      this.data,
+    ]);
+  }
+
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_ExternalFormatData(this);
+  }
+}
+
+export class ModelStoreData extends EmbeddedData implements Hashable {
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   * TODO: we may want to build out the instance `objects` once we build out the form
+   *
+   * @discrepancy model
+   */
+  instances!: Map<Class, object>;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MODEL_STORE_DATA,
+      hashArray(Array.from(this.instances.keys()).map((e) => e.path)),
+      hashObjectWithoutSourceInformation(Array.from(this.instances.values())),
+    ]);
+  }
+
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_ModelStoreData(this);
+  }
+}