@finos/legend-graph 9.0.1 → 10.1.1

package/src/models/protocols/pure/v1/engine/V1_Engine.ts

@@ -83,7 +83,7 @@ import { V1_ServiceStorage } from './service/V1_ServiceStorage.js';
 import { V1_ServiceRegistrationResult } from './service/V1_ServiceRegistrationResult.js';
 import type { V1_PureModelContext } from '../model/context/V1_PureModelContext.js';
 import { ServiceExecutionMode } from '../../../../../graphManager/action/service/ServiceExecutionMode.js';
-import { serialize } from 'serializr';
+import { deserialize, serialize } from 'serializr';
 import { V1_ExecutionError } from './execution/V1_ExecutionError.js';
 import { V1_PureModelContextText } from '../model/context/V1_PureModelContextText.js';
 import { V1_QuerySearchSpecification } from './query/V1_QuerySearchSpecification.js';
@@ -95,6 +95,10 @@ import { GRAPH_MANAGER_EVENT } from '../../../../../graphManager/GraphManagerEve
 import { V1_RunTestsInput } from './test/V1_RunTestsInput.js';
 import { V1_RunTestsResult } from './test/V1_RunTestsResult.js';
 import { V1_RenderStyle } from './grammar/V1_RenderStyle.js';
+import {
+  V1_MappingModelCoverageAnalysisInput,
+  V1_MappingModelCoverageAnalysisResult,
+} from './analytics/V1_MappingAnalytics.js';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -176,6 +180,10 @@ export class V1_Engine {
     return this.engineServerClient;
   }
 
+  getCurrentUserId(): string | undefined {
+    return this.engineServerClient.currentUserId;
+  }
+
   async setup(config: V1_EngineSetupConfig): Promise<void> {
     this.config.setEnv(config.env);
     this.config.setTabSize(config.tabSize);
@@ -267,7 +275,7 @@ export class V1_Engine {
     pretty: boolean,
     plugins: PureProtocolProcessorPlugin[],
   ): Promise<string> {
-    return await this.engineServerClient.JSONToGrammar_lambda(
+    return this.engineServerClient.JSONToGrammar_lambda(
       V1_serializeRawValueSpecification(
         V1_transformRawLambda(
           lambda,
@@ -497,7 +505,7 @@ export class V1_Engine {
     );
   }
 
-  generateMappingTestData(
+  generateExecuteTestData(
     input: V1_TestDataGenerationExecutionInput,
   ): Promise<string> {
     return this.engineServerClient.generateTestDataWithDefaultSeed(
@@ -719,6 +727,19 @@ export class V1_Engine {
     await this.engineServerClient.deleteQuery(queryId);
   }
 
+  // ------------------------------------------ Analysis ------------------------------------------
+
+  async analyzeMappingModelCoverage(
+    input: V1_MappingModelCoverageAnalysisInput,
+  ): Promise<V1_MappingModelCoverageAnalysisResult> {
+    return deserialize(
+      V1_MappingModelCoverageAnalysisResult,
+      await this.engineServerClient.analyzeMappingModelCoverage(
+        V1_MappingModelCoverageAnalysisInput.serialization.toJson(input),
+      ),
+    );
+  }
+
   // --------------------------------------------- Utilities ---------------------------------------------
 
   async buildDatabase(

package/src/models/protocols/pure/v1/engine/V1_EngineServerClient.ts

@@ -51,6 +51,7 @@ import type { V1_TestResult } from '../model/test/result/V1_TestResult.js';
 import type { V1_RawRelationalOperationElement } from '../model/packageableElements/store/relational/model/V1_RawRelationalOperationElement.js';
 import type { V1_RenderStyle } from './grammar/V1_RenderStyle.js';
 import type { V1_ParserError } from './grammar/V1_ParserError.js';
+import type { V1_MappingModelCoverageAnalysisResult } from './analytics/V1_MappingAnalytics.js';
 
 enum CORE_ENGINE_TRACER_SPAN {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -77,6 +78,8 @@ enum CORE_ENGINE_TRACER_SPAN {
   CREATE_QUERY = 'create query',
   UPDATE_QUERY = 'update query',
   DELETE_QUERY = 'delete query',
+
+  MODEL_ANALYTICS = 'model analytics',
 }
 
 type GrammarParserBatchInputEntry = {
@@ -501,6 +504,21 @@ export class V1_EngineServerClient extends AbstractServerClient {
       { enableCompression: true },
     );
 
+  // --------------------------------------- Analysis ---------------------------------------
+
+  analyzeMappingModelCoverage = (
+    input: PlainObject<V1_MappingModelCoverageAnalysisResult>,
+  ): Promise<PlainObject<V1_MappingModelCoverageAnalysisResult>> =>
+    this.postWithTracing(
+      this.getTraceData(CORE_ENGINE_TRACER_SPAN.MODEL_ANALYTICS),
+      `${this._pure()}/analytics/mapping/modelCoverage`,
+      input,
+      {},
+      undefined,
+      undefined,
+      { enableCompression: true },
+    );
+
   // ------------------------------------------- Utilities -------------------------------------------
 
   _utilities = (): string => `${this._pure()}/utilities`;

package/src/models/protocols/pure/v1/engine/analytics/V1_MappingAnalytics.ts

@@ -0,0 +1,168 @@
+/**
+ * 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 PlainObject,
+  SerializationFactory,
+  usingModelSchema,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  list,
+  object,
+  optional,
+  primitive,
+  serialize,
+} from 'serializr';
+import {
+  EntityMappedProperty,
+  EnumMappedProperty,
+  MappedEntity,
+  MappedProperty,
+  MappingModelCoverageAnalysisResult,
+} from '../../../../../../graphManager/action/analytics/MappingAnalytics.js';
+import { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData.js';
+
+enum V1_MappedPropertyType {
+  ENUM = 'enum',
+  ENTITY = 'entity',
+}
+
+class V1_MappedProperty {
+  name!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappedProperty, {
+      name: primitive(),
+    }),
+  );
+}
+
+class V1_EntityMappedProperty extends V1_MappedProperty {
+  entityPath!: string;
+  subType: string | undefined;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_EntityMappedProperty, {
+      name: primitive(),
+      entityPath: primitive(),
+      subType: optional(primitive()),
+    }),
+  );
+}
+
+class V1_EnumMappedProperty extends V1_MappedProperty {
+  enumPath!: string;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_EnumMappedProperty, {
+      name: primitive(),
+      enumPath: primitive(),
+    }),
+  );
+}
+
+const V1_serializeMappedProperty = (
+  prop: V1_MappedProperty,
+): V1_MappedProperty =>
+  V1_MappedProperty instanceof V1_EnumMappedProperty
+    ? serialize(V1_EnumMappedProperty.serialization.schema, prop)
+    : V1_MappedProperty instanceof V1_EntityMappedProperty
+    ? serialize(V1_EntityMappedProperty.serialization.schema, prop)
+    : serialize(V1_MappedProperty.serialization.schema, prop);
+
+const V1_deserializeMappedProperty = (
+  json: PlainObject<V1_MappedProperty>,
+): V1_MappedProperty => {
+  switch (json._type) {
+    case V1_MappedPropertyType.ENTITY:
+      return deserialize(V1_EntityMappedProperty.serialization.schema, json);
+    case V1_MappedPropertyType.ENUM:
+      return deserialize(V1_EnumMappedProperty.serialization.schema, json);
+    default: {
+      return deserialize(V1_MappedProperty.serialization.schema, json);
+    }
+  }
+};
+
+class V1_MappedEntity {
+  path!: string;
+  properties: V1_MappedProperty[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappedEntity, {
+      path: primitive(),
+      properties: list(
+        custom(
+          (prop) => V1_serializeMappedProperty(prop),
+          (prop) => V1_deserializeMappedProperty(prop),
+        ),
+      ),
+    }),
+  );
+}
+
+export class V1_MappingModelCoverageAnalysisInput {
+  clientVersion!: string;
+  mapping!: string;
+  model!: V1_PureModelContextData;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappingModelCoverageAnalysisInput, {
+      clientVersion: primitive(),
+      mapping: primitive(),
+      model: object(V1_PureModelContextData),
+    }),
+  );
+}
+
+export class V1_MappingModelCoverageAnalysisResult {
+  mappedEntities: V1_MappedEntity[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappingModelCoverageAnalysisResult, {
+      mappedEntities: list(
+        usingModelSchema(V1_MappedEntity.serialization.schema),
+      ),
+    }),
+  );
+}
+
+const buildMappedProperty = (protocol: V1_MappedProperty): MappedProperty =>
+  protocol instanceof V1_EntityMappedProperty
+    ? new EntityMappedProperty(
+        protocol.name,
+        protocol.entityPath,
+        protocol.subType,
+      )
+    : protocol instanceof V1_EnumMappedProperty
+    ? new EnumMappedProperty(protocol.name, protocol.enumPath)
+    : new MappedProperty(protocol.name);
+
+const buildMappedEntity = (protocol: V1_MappedEntity): MappedEntity =>
+  new MappedEntity(
+    protocol.path,
+    protocol.properties.map((p) => buildMappedProperty(p)),
+  );
+
+export const V1_buildModelCoverageAnalysisResult = (
+  protocol: V1_MappingModelCoverageAnalysisResult,
+): MappingModelCoverageAnalysisResult =>
+  new MappingModelCoverageAnalysisResult(
+    protocol.mappedEntities.map((p) => buildMappedEntity(p)),
+  );

package/src/models/protocols/pure/v1/engine/{V1_ExecutionHelper.ts → execution/V1_ExecutionHelper.ts}

@@ -28,7 +28,7 @@ import {
   TdsBuilder,
   TDSColumn,
   RawExecutionResult,
-} from '../../../../../graphManager/action/execution/ExecutionResult.js';
+} from '../../../../../../graphManager/action/execution/ExecutionResult.js';
 import {
   type V1_ExecutionResult,
   type V1_TdsBuilder,
@@ -37,7 +37,7 @@ import {
   V1_INTERNAL__UnknownExecutionResult,
   V1_TdsExecutionResult,
   V1_RawExecutionResult,
-} from './execution/V1_ExecutionResult.js';
+} from './V1_ExecutionResult.js';
 
 const buildJSONExecutionResult = (
   protocol: V1_JsonExecutionResult,

package/src/models/protocols/pure/v1/model/data/V1_EmbeddedData.ts

@@ -17,14 +17,14 @@
 import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../MetaModelConst.js';
 import { hashObjectWithoutSourceInformation } from '../../../../../../MetaModelUtils.js';
-import type { V1_RelationalData } from './V1_RelationalData.js';
+import type { V1_RelationalCSVData } from './V1_RelationalCSVData.js';
 
 export interface V1_EmbeddedDataVisitor<T> {
   visit_EmbeddedData(embeddedData: V1_EmbeddedData): T;
   visit_ExternalFormatData(externalFormatData: V1_ExternalFormatData): T;
   visit_ModelStoreData(modelStoreData: V1_ModelStoreData): T;
   visit_DataElementReference(dataElementReference: V1_DataElementReference): T;
-  visit_RelationalData(relationalData: V1_RelationalData): T;
+  visit_RelationalData(relationalData: V1_RelationalCSVData): T;
 }
 
 export abstract class V1_EmbeddedData implements Hashable {

package/src/models/protocols/pure/v1/model/data/{V1_RelationalData.ts → V1_RelationalCSVData.ts}

@@ -21,47 +21,23 @@ import {
   type V1_EmbeddedDataVisitor,
 } from './V1_EmbeddedData.js';
 
-export class V1_RelationalDataTableColumn implements Hashable {
-  value!: string;
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE_COLUMN,
-      this.value,
-    ]);
-  }
-}
-
-export class V1_RelationalDataTableRow implements Hashable {
+export class V1_RelationalCSVDataTable implements Hashable {
+  schema!: string;
+  table!: string;
   values!: string;
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE_ROW,
+      CORE_HASH_STRUCTURE.RELATIONAL_CSV_DATA_TABLE,
+      this.schema,
+      this.table,
       this.values,
     ]);
   }
 }
 
-export class V1_RelationalDataTable implements Hashable {
-  schemaName: string | undefined;
-  tableName!: string;
-  columns: V1_RelationalDataTableColumn[] = [];
-  rows: V1_RelationalDataTableRow[] = [];
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE,
-      this.schemaName ?? '',
-      this.tableName,
-      hashArray(this.columns),
-      hashArray(this.rows),
-    ]);
-  }
-}
-
-export class V1_RelationalData extends V1_EmbeddedData implements Hashable {
-  tables: V1_RelationalDataTable[] = [];
+export class V1_RelationalCSVData extends V1_EmbeddedData implements Hashable {
+  tables: V1_RelationalCSVDataTable[] = [];
 
   accept_EmbeddedDataVisitor<T>(visitor: V1_EmbeddedDataVisitor<T>): T {
     return visitor.visit_RelationalData(this);
@@ -69,7 +45,7 @@ export class V1_RelationalData extends V1_EmbeddedData implements Hashable {
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE,
+      CORE_HASH_STRUCTURE.RELATIONAL_CSV_DATA_TABLE,
       hashArray(this.tables),
     ]);
   }

package/src/models/protocols/pure/v1/model/packageableElements/service/V1_ServiceTest.ts

@@ -20,6 +20,7 @@ import { V1_AtomicTest } from '../../test/V1_AtomicTest.js';
 import type { V1_ParameterValue } from './V1_ParameterValue.js';
 
 export class V1_ServiceTest extends V1_AtomicTest implements Hashable {
+  serializationFormat: string | undefined;
   parameters: V1_ParameterValue[] = [];
 
   get hashCode(): string {
@@ -28,6 +29,7 @@ export class V1_ServiceTest extends V1_AtomicTest implements Hashable {
       this.id,
       hashArray(this.assertions),
       hashArray(this.parameters),
+      this.serializationFormat ?? '',
     ]);
   }
 }

package/src/models/protocols/pure/v1/model/test/assertion/V1_EqualToTDS.ts

@@ -14,32 +14,16 @@
  * limitations under the License.
  */
 
-import { hashArray, type Hashable } from '@finos/legend-shared';
+import { hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst.js';
-import type {
-  V1_RelationalDataTableColumn,
-  V1_RelationalDataTableRow,
-} from '../../data/V1_RelationalData.js';
+import type { V1_ExternalFormatData } from '../../data/V1_EmbeddedData.js';
 import {
   type V1_TestAssertionVisitor,
   V1_TestAssertion,
 } from './V1_TestAssertion.js';
 
-export class V1_RelationalTDS implements Hashable {
-  columns: V1_RelationalDataTableColumn[] = [];
-  rows: V1_RelationalDataTableRow[] = [];
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_TDS,
-      hashArray(this.columns),
-      hashArray(this.rows),
-    ]);
-  }
-}
-
 export class V1_EqualToTDS extends V1_TestAssertion {
-  expected!: V1_RelationalTDS;
+  expected!: V1_ExternalFormatData;
 
   get hashCode(): string {
     return hashArray([

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_DataElementTransformer.ts

@@ -22,9 +22,9 @@ import {
   ModelStoreData,
 } from '../../../../../../metamodels/pure/data/EmbeddedData.js';
 import {
-  type RelationalDataTable,
-  RelationalData,
-} from '../../../../../../metamodels/pure/data/RelationalData.js';
+  type RelationalCSVDataTable,
+  RelationalCSVData,
+} from '../../../../../../metamodels/pure/data/RelationalCSVData.js';
 import type { DataElement } from '../../../../../../metamodels/pure/packageableElements/data/DataElement.js';
 import type { DSLData_PureProtocolProcessorPlugin_Extension } from '../../../../DSLData_PureProtocolProcessorPlugin_Extension.js';
 import {
@@ -34,11 +34,9 @@ import {
   V1_ModelStoreData,
 } from '../../../model/data/V1_EmbeddedData.js';
 import {
-  V1_RelationalData,
-  V1_RelationalDataTable,
-  V1_RelationalDataTableColumn,
-  V1_RelationalDataTableRow,
-} from '../../../model/data/V1_RelationalData.js';
+  V1_RelationalCSVData,
+  V1_RelationalCSVDataTable,
+} from '../../../model/data/V1_RelationalCSVData.js';
 import { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement.js';
 import { V1_initPackageableElement } from './V1_CoreTransformerHelper.js';
 import {
@@ -79,30 +77,21 @@ const V1_transformDataElementReference = (
   return dataElementReference;
 };
 
-const V1_transformRelationalDataTable = (
-  element: RelationalDataTable,
-): V1_RelationalDataTable => {
-  const table = new V1_RelationalDataTable();
-  table.tableName = element.tableName;
-  table.schemaName = element.schemaName;
-  table.rows = element.rows.map((e) => {
-    const row = new V1_RelationalDataTableRow();
-    row.values = e.values;
-    return row;
-  });
-  table.columns = element.columns.map((e) => {
-    const col = new V1_RelationalDataTableColumn();
-    col.value = e.value;
-    return col;
-  });
+const V1_transformRelationalCSVDataTable = (
+  element: RelationalCSVDataTable,
+): V1_RelationalCSVDataTable => {
+  const table = new V1_RelationalCSVDataTable();
+  table.table = element.table;
+  table.schema = element.schema;
+  table.values = element.values;
   return table;
 };
 
-const V1_transformRelationalData = (
-  element: RelationalData,
-): V1_RelationalData => {
-  const data = new V1_RelationalData();
-  data.tables = element.tables.map(V1_transformRelationalDataTable);
+const V1_transformRelationalCSVData = (
+  element: RelationalCSVData,
+): V1_RelationalCSVData => {
+  const data = new V1_RelationalCSVData();
+  data.tables = element.tables.map(V1_transformRelationalCSVDataTable);
   return data;
 };
 
@@ -116,8 +105,8 @@ export const V1_transformEmbeddedData = (
     return V1_transformExternalFormatData(metamodel);
   } else if (metamodel instanceof DataElementReference) {
     return V1_transformDataElementReference(metamodel);
-  } else if (metamodel instanceof RelationalData) {
-    return V1_transformRelationalData(metamodel);
+  } else if (metamodel instanceof RelationalCSVData) {
+    return V1_transformRelationalCSVData(metamodel);
   }
   const extraEmbeddedDataTransformers = context.plugins.flatMap(
     (plugin) =>

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_ServiceTransformer.ts

@@ -105,6 +105,7 @@ export const V1_transformServiceTest = (
 ): V1_ServiceTest => {
   const serviceTest = new V1_ServiceTest();
   serviceTest.id = element.id;
+  serviceTest.serializationFormat = element.serializationFormat;
   serviceTest.parameters = element.parameters.map((parameter) =>
     transformParameterValue(parameter),
   );

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_TestTransformer.ts

@@ -36,10 +36,7 @@ import type {
   TestSuite,
 } from '../../../../../../metamodels/pure/test/Test.js';
 import { EqualToTDS } from '../../../../../../metamodels/pure/test/assertion/EqualToTDS.js';
-import {
-  V1_EqualToTDS,
-  V1_RelationalTDS,
-} from '../../../model/test/assertion/V1_EqualToTDS.js';
+import { V1_EqualToTDS } from '../../../model/test/assertion/V1_EqualToTDS.js';
 
 const transformEqualTo = (element: EqualTo): V1_EqualTo => {
   const equalTo = new V1_EqualTo();
@@ -58,9 +55,7 @@ const transformEqualToJson = (element: EqualToJson): V1_EqualToJson => {
 const transformEqualToTDS = (element: EqualToTDS): V1_EqualToTDS => {
   const equalToTDS = new V1_EqualToTDS();
   equalToTDS.id = element.id;
-  equalToTDS.expected = new V1_RelationalTDS();
-  equalToTDS.expected.columns = element.expected.columns;
-  equalToTDS.expected.rows = element.expected.rows;
+  equalToTDS.expected = V1_transformExternalFormatData(element.expected);
   return equalToTDS;
 };
 

package/src/models/protocols/pure/v1/transformation/pureGraph/to/V1_ProtocolToMetaModelGraphSecondPassBuilder.ts

@@ -82,6 +82,7 @@ import { V1_ProtocolToMetaModelEmbeddedDataBuilder } from './helpers/V1_DataElem
 import { V1_buildTestSuite } from './helpers/V1_TestBuilderHelper.js';
 import { ServiceTestSuite } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestSuite.js';
 import { V1_getIncludedMappingPath } from '../../../helper/V1_DSLMapping_Helper.js';
+import { V1_DataElementReference } from '../../../model/data/V1_EmbeddedData.js';
 
 export class V1_ProtocolToMetaModelGraphSecondPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -329,7 +330,7 @@ export class V1_ProtocolToMetaModelGraphSecondPassBuilder
       );
     }
     service.tests = element.testSuites
-      .map((testSuite) => V1_buildTestSuite(testSuite, this.context))
+      .map((testSuite) => V1_buildTestSuite(service, testSuite, this.context))
       .map((e) => guaranteeType(e, ServiceTestSuite));
   }
 
@@ -407,6 +408,11 @@ export class V1_ProtocolToMetaModelGraphSecondPassBuilder
     dataElement.taggedValues = element.taggedValues
       .map((taggedValue) => V1_buildTaggedValue(taggedValue, this.context))
       .filter(isNonNullable);
+    if (element.data instanceof V1_DataElementReference) {
+      throw new IllegalStateError(
+        'Cannot use Data element reference in a Data element',
+      );
+    }
     dataElement.data = element.data.accept_EmbeddedDataVisitor(
       new V1_ProtocolToMetaModelEmbeddedDataBuilder(this.context),
     );

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_DataElementBuilderHelper.ts

@@ -22,11 +22,9 @@ import {
   ModelStoreData,
 } from '../../../../../../../metamodels/pure/data/EmbeddedData.js';
 import {
-  RelationalData,
-  RelationalDataTable,
-  RelationalDataTableColumn,
-  RelationalDataTableRow,
-} from '../../../../../../../metamodels/pure/data/RelationalData.js';
+  RelationalCSVData,
+  RelationalCSVDataTable,
+} from '../../../../../../../metamodels/pure/data/RelationalCSVData.js';
 import type { Class } from '../../../../../../../metamodels/pure/packageableElements/domain/Class.js';
 import type { DSLData_PureProtocolProcessorPlugin_Extension } from '../../../../../DSLData_PureProtocolProcessorPlugin_Extension.js';
 import type {
@@ -36,8 +34,7 @@ import type {
   V1_ExternalFormatData,
   V1_ModelStoreData,
 } from '../../../../model/data/V1_EmbeddedData.js';
-import type { V1_RelationalData } from '../../../../model/data/V1_RelationalData.js';
-
+import type { V1_RelationalCSVData } from '../../../../model/data/V1_RelationalCSVData.js';
 import type { V1_GraphBuilderContext } from '../V1_GraphBuilderContext.js';
 
 export class V1_ProtocolToMetaModelEmbeddedDataBuilder
@@ -98,22 +95,13 @@ export class V1_ProtocolToMetaModelEmbeddedDataBuilder
     return metamodel;
   }
 
-  visit_RelationalData(relationalData: V1_RelationalData): EmbeddedData {
-    const metamodel = new RelationalData();
+  visit_RelationalData(relationalData: V1_RelationalCSVData): EmbeddedData {
+    const metamodel = new RelationalCSVData();
     metamodel.tables = relationalData.tables.map((t) => {
-      const table = new RelationalDataTable();
-      table.schemaName = t.schemaName;
-      table.columns = t.columns.map((c) => {
-        const col = new RelationalDataTableColumn();
-        col.value = c.value;
-        return col;
-      });
-      table.tableName = t.tableName;
-      table.rows = t.rows.map((r) => {
-        const row = new RelationalDataTableRow();
-        row.values = r.values;
-        return row;
-      });
+      const table = new RelationalCSVDataTable();
+      table.schema = t.schema;
+      table.table = t.table;
+      table.values = t.values;
       return table;
     });
     return metamodel;

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_DatabaseBuilderHelper.ts

@@ -161,6 +161,12 @@ const schemaExists = (database: Database, _schema: string): boolean =>
   DEFAULT_DATABASE_SCHEMA_NAME === _schema ||
   _schemaExists(database, _schema, new Set<Database>());
 
+export const V1_findSchema = (database: Database, _schema: string): void =>
+  assertTrue(
+    schemaExists(database, _schema),
+    `Can't find schema '${_schema}' in database '${database}'`,
+  );
+
 export const V1_findRelation = (
   database: Database,
   schemaName: string,
@@ -193,10 +199,7 @@ export const V1_getRelation = (
   schemaName: string,
   relationName: string,
 ): Relation => {
-  assertTrue(
-    schemaExists(db, schemaName),
-    `Can't find schema '${schemaName}' in database '${db}'`,
-  );
+  V1_findSchema(db, schemaName);
   return guaranteeNonNullable(
     V1_findRelation(db, schemaName, relationName),
     `Can't find table '${relationName}' in schema '${schemaName}' and database '${db.path}'`,