@finos/legend-graph 9.0.0 → 10.1.0

package/src/graphManager/action/analytics/MappingAnalytics.ts

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+
+export type RawMappingModelCoverageAnalysisResult = object;
+
+export class MappedEntity {
+  readonly __NAME_TO_PROPERTY!: Map<string, MappedProperty>;
+
+  path: string;
+  properties: MappedProperty[];
+
+  constructor(path: string, properties: MappedProperty[]) {
+    this.path = path;
+    this.properties = properties;
+    this.__NAME_TO_PROPERTY = new Map<string, MappedProperty>();
+    properties.map((p) => this.__NAME_TO_PROPERTY.set(p.name, p));
+  }
+}
+
+export class MappedProperty {
+  name: string;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+
+export class EntityMappedProperty extends MappedProperty {
+  entityPath: string;
+  subType: string | undefined;
+
+  constructor(name: string, entityPath: string, subType: string | undefined) {
+    super(name);
+    this.entityPath = entityPath;
+    this.subType = subType;
+  }
+}
+
+export class EnumMappedProperty extends MappedProperty {
+  enumPath: string;
+
+  constructor(name: string, enumPath: string) {
+    super(name);
+    this.enumPath = enumPath;
+  }
+}
+
+export class MappingModelCoverageAnalysisResult {
+  readonly __PATH_TO_ENTITY!: Map<string, MappedEntity>;
+
+  mappedEntities: MappedEntity[];
+
+  constructor(mappedEntities: MappedEntity[]) {
+    this.mappedEntities = mappedEntities;
+    this.__PATH_TO_ENTITY = new Map<string, MappedEntity>();
+    mappedEntities.map((e) => this.__PATH_TO_ENTITY.set(e.path, e));
+  }
+}

package/src/graphManager/action/changeDetection/DSLData_ObserverHelper.ts

@@ -22,11 +22,9 @@ import {
   ModelStoreData,
 } from '../../../models/metamodels/pure/data/EmbeddedData.js';
 import {
-  type RelationalDataTable,
-  type RelationalDataTableColumn,
-  type RelationalDataTableRow,
-  RelationalData,
-} from '../../../models/metamodels/pure/data/RelationalData.js';
+  type RelationalCSVDataTable,
+  RelationalCSVData,
+} from '../../../models/metamodels/pure/data/RelationalCSVData.js';
 import type { DataElement } from '../../../models/metamodels/pure/packageableElements/data/DataElement.js';
 import type { EmbeddedData_PureGraphManagerPlugin_Extension } from '../../EmbeddedData_PureGraphManagerPlugin_Extension.js';
 import {
@@ -74,39 +72,20 @@ export const observe_ModelStoreData = skipObserved(
   },
 );
 
-export const observe_RelationalDataTableColumn = skipObserved(
-  (metamodel: RelationalDataTableColumn): RelationalDataTableColumn => {
+export const observe_RelationalDataTable = skipObserved(
+  (metamodel: RelationalCSVDataTable): RelationalCSVDataTable => {
     makeObservable(metamodel, {
+      values: observable,
+      table: observable,
+      schema: observable,
       hashCode: computed,
     });
     return metamodel;
   },
 );
 
-export const observe_RelationalDataTableRow = skipObserved(
-  (metamodel: RelationalDataTableRow): RelationalDataTableRow => {
-    makeObservable(metamodel, {
-      hashCode: computed,
-    });
-    return metamodel;
-  },
-);
-
-const observe_RelationalDataTable = skipObserved(
-  (metamodel: RelationalDataTable): RelationalDataTable => {
-    makeObservable(metamodel, {
-      columns: observable,
-      rows: observable,
-      hashCode: computed,
-    });
-    metamodel.columns.forEach(observe_RelationalDataTableColumn);
-    metamodel.rows.forEach(observe_RelationalDataTableRow);
-    return metamodel;
-  },
-);
-
-const observe_RelationalData = skipObserved(
-  (metamodel: RelationalData): RelationalData => {
+const observe_RelationalCSVData = skipObserved(
+  (metamodel: RelationalCSVData): RelationalCSVData => {
     makeObservable(metamodel, {
       tables: observable,
       hashCode: computed,
@@ -126,8 +105,8 @@ export function observe_EmbeddedData(
     return observe_ExternalFormatData(metamodel);
   } else if (metamodel instanceof ModelStoreData) {
     return observe_ModelStoreData(metamodel);
-  } else if (metamodel instanceof RelationalData) {
-    return observe_RelationalData(metamodel);
+  } else if (metamodel instanceof RelationalCSVData) {
+    return observe_RelationalCSVData(metamodel);
   }
   const extraEmbeddedDataObservers = context.plugins.flatMap(
     (plugin) =>

package/src/graphManager/action/changeDetection/DSLService_ObserverHelper.ts

@@ -75,7 +75,7 @@ export const observe_ParameterValue = skipObserved(
   (metamodel: ParameterValue): ParameterValue => {
     makeObservable(metamodel, {
       name: observable,
-      value: observable,
+      value: observable.ref,
       hashCode: computed,
     });
 
@@ -102,6 +102,7 @@ export const observe_ServiceTest = skipObserved(
   (metamodel: ServiceTest): ServiceTest => {
     makeObservable(metamodel, {
       id: observable,
+      serializationFormat: observable,
       assertions: observable,
       parameters: observable,
       hashCode: computed,

package/src/graphManager/action/changeDetection/Testable_ObserverHelper.ts

@@ -19,21 +19,14 @@ import { ServiceTest } from '../../../DSLService_Exports.js';
 import { ServiceTestSuite } from '../../../models/metamodels/pure/packageableElements/service/ServiceTestSuite.js';
 import { EqualTo } from '../../../models/metamodels/pure/test/assertion/EqualTo.js';
 import { EqualToJson } from '../../../models/metamodels/pure/test/assertion/EqualToJson.js';
-import {
-  EqualToTDS,
-  type RelationalTDS,
-} from '../../../models/metamodels/pure/test/assertion/EqualToTDS.js';
+import { EqualToTDS } from '../../../models/metamodels/pure/test/assertion/EqualToTDS.js';
 import type { TestAssertion } from '../../../models/metamodels/pure/test/assertion/TestAssertion.js';
 import type {
   AtomicTest,
   TestSuite,
 } from '../../../models/metamodels/pure/test/Test.js';
 import { type ObserverContext, skipObserved } from './CoreObserverHelper.js';
-import {
-  observe_ExternalFormatData,
-  observe_RelationalDataTableColumn,
-  observe_RelationalDataTableRow,
-} from './DSLData_ObserverHelper.js';
+import { observe_ExternalFormatData } from './DSLData_ObserverHelper.js';
 import {
   observe_ServiceTest,
   observe_ServiceTestSuite,
@@ -49,26 +42,13 @@ const observe_EqualTo = skipObserved((metamodel: EqualTo): EqualTo => {
   return metamodel;
 });
 
-const observe_RelationalTDS = skipObserved(
-  (metamodel: RelationalTDS): RelationalTDS => {
-    makeObservable(metamodel, {
-      rows: observable,
-      columns: observable,
-      hashCode: computed,
-    });
-    metamodel.columns.forEach(observe_RelationalDataTableColumn);
-    metamodel.rows.forEach(observe_RelationalDataTableRow);
-    return metamodel;
-  },
-);
-
 const observe_EqualToTDS = skipObserved((metamodel: EqualToTDS): EqualToTDS => {
   makeObservable(metamodel, {
     id: observable,
     expected: observable,
     hashCode: computed,
   });
-  observe_RelationalTDS(metamodel.expected);
+  observe_ExternalFormatData(metamodel.expected);
   return metamodel;
 });
 

package/src/graphManager/action/creation/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 '../../../models/metamodels/pure/data/EmbeddedData.js';
+
+export const isStubbed_ExternalFormatData = (
+  value: ExternalFormatData,
+): boolean => value.data === '';

package/src/graphManager/action/creation/DSLMapping_ModelCreatorHelper.ts

@@ -15,6 +15,7 @@
  */
 
 import { isNonNullable } from '@finos/legend-shared';
+import { PackageableRuntime } from '../../../DSLMapping_Exports.js';
 import type { EnumValueMapping } from '../../../models/metamodels/pure/packageableElements/mapping/EnumValueMapping.js';
 import { Mapping } from '../../../models/metamodels/pure/packageableElements/mapping/Mapping.js';
 import type { SetImplementationContainer } from '../../../models/metamodels/pure/packageableElements/mapping/SetImplementationContainer.js';
@@ -32,3 +33,6 @@ export const isStubbed_StoreConnections = (value: StoreConnections): boolean =>
 export const isStubbed_SetImplementationContainer = (
   value: SetImplementationContainer,
 ): boolean => !value.setImplementation.value.id.value;
+
+export const stub_PackageableRuntime = (): PackageableRuntime =>
+  new PackageableRuntime('');

package/src/helpers/Testable_Helper.ts

@@ -20,6 +20,10 @@ import type { PureGraphManagerPlugin } from '../graphManager/PureGraphManagerPlu
 import { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement.js';
 import type { Testable } from '../models/metamodels/pure/test/Testable.js';
 
+export const DEFAULT_TEST_SUITE_PREFIX = 'testSuite';
+export const DEFAULT_TEST_PREFIX = 'test';
+export const DEFAULT_TEST_ASSERTION_PREFIX = 'assertion';
+
 export const getNullableTestable = (
   id: string,
   graph: PureModel,

package/src/helpers/ValueSpecificationHelper.ts

@@ -14,22 +14,35 @@
  * limitations under the License.
  */
 
-import { guaranteeType } from '@finos/legend-shared';
+import { guaranteeType, Randomizer } from '@finos/legend-shared';
 import type { PureModel } from '../graph/PureModel.js';
+import type { GraphManagerState } from '../GraphManagerState.js';
 import {
-  type GraphManagerState,
-  type LambdaFunction,
-  type ValueSpecification,
-  LambdaFunctionInstanceValue,
-  RawLambda,
-} from '../index.js';
-import {
-  type PRIMITIVE_TYPE,
+  DATE_FORMAT,
+  DATE_TIME_FORMAT,
+  PRIMITIVE_TYPE,
   TYPICAL_MULTIPLICITY_TYPE,
 } from '../MetaModelConst.js';
+import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration.js';
+import { EnumValueExplicitReference } from '../models/metamodels/pure/packageableElements/domain/EnumValueReference.js';
 import { GenericType } from '../models/metamodels/pure/packageableElements/domain/GenericType.js';
 import { GenericTypeExplicitReference } from '../models/metamodels/pure/packageableElements/domain/GenericTypeReference.js';
-import { PrimitiveInstanceValue } from '../models/metamodels/pure/valueSpecification/InstanceValue.js';
+import { PrimitiveType } from '../models/metamodels/pure/packageableElements/domain/PrimitiveType.js';
+import { RawLambda } from '../models/metamodels/pure/rawValueSpecification/RawLambda.js';
+import {
+  type InstanceValue,
+  CollectionInstanceValue,
+  EnumValueInstanceValue,
+  PrimitiveInstanceValue,
+} from '../models/metamodels/pure/valueSpecification/InstanceValue.js';
+import {
+  type LambdaFunction,
+  LambdaFunctionInstanceValue,
+} from '../models/metamodels/pure/valueSpecification/LambdaFunction.js';
+import type { ValueSpecification } from '../models/metamodels/pure/valueSpecification/ValueSpecification.js';
+import type { VariableExpression } from '../models/metamodels/pure/valueSpecification/VariableExpression.js';
+import { getEnumValue } from './DomainHelper.js';
+import { format, addDays } from 'date-fns';
 
 export const buildPrimitiveInstanceValue = (
   graph: PureModel,
@@ -79,3 +92,86 @@ export const buildRawLambdaFromLambdaFunction = (
     RawLambda,
   );
 };
+
+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/index.ts

@@ -188,6 +188,7 @@ export { GraphManagerState } from './GraphManagerState.js';
 export * from './GraphManagerStateProvider.js';
 export * from './GraphManagerTestUtils.js';
 export {
+  AbstractPureGraphManagerExtension,
   AbstractPureGraphManager,
   type GraphBuilderOptions,
 } from './graphManager/AbstractPureGraphManager.js';
@@ -218,7 +219,14 @@ export { ServiceExecutionMode } from './graphManager/action/service/ServiceExecu
 export { ServiceRegistrationResult } from './graphManager/action/service/ServiceRegistrationResult.js';
 export { DEPRECATED__ServiceTestResult } from './graphManager/action/service/DEPRECATED__ServiceTestResult.js';
 export { SourceInformation } from './graphManager/action/SourceInformation.js';
-
+export {
+  MappingModelCoverageAnalysisResult,
+  MappedEntity,
+  MappedProperty,
+  EntityMappedProperty,
+  EnumMappedProperty,
+} from './graphManager/action/analytics/MappingAnalytics.js';
+export { V1_MappingModelCoverageAnalysisResult } from './models/protocols/pure/v1/engine/analytics/V1_MappingAnalytics.js';
 export * from './models/protocols/pure/PureProtocolProcessorPlugin.js';
 
 // --------------------------------------------- TRANSFORMATION --------------------------------------------------
@@ -289,6 +297,9 @@ export * from './models/metamodels/pure/test/assertion/status/AssertPass.js';
 export * from './models/metamodels/pure/test/assertion/status/EqualToJsonAssertFail.js';
 export * from './models/metamodels/pure/test/assertion/TestAssertion.js';
 export * from './models/metamodels/pure/test/Test.js';
+export * from './models/metamodels/pure/test/assertion/EqualTo.js';
+export * from './models/metamodels/pure/test/assertion/EqualToJson.js';
+export * from './models/metamodels/pure/test/assertion/EqualToTDS.js';
 export * from './models/metamodels/pure/test/result/AtomicTestId.js';
 
 // --------------------------------------------- VALIDATION --------------------------------------------------
@@ -311,6 +322,7 @@ export * from './graphManager/action/changeDetection/GraphObserverHelper.js';
 export * from './graphManager/action/changeDetection/DSLExternalFormat_ObserverHelper.js';
 export * from './graphManager/action/changeDetection/DSLService_ObserverHelper.js';
 export * from './graphManager/action/changeDetection/DSLGenerationSpecification_ObserverHelper.js';
+export * from './graphManager/action/changeDetection/Testable_ObserverHelper.js';
 
 export * from './graphManager/action/changeDetection/EngineObserverHelper.js';
 

package/src/models/metamodels/pure/data/EmbeddedData.ts

@@ -20,14 +20,14 @@ import { hashObjectWithoutSourceInformation } from '../../../../MetaModelUtils.j
 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 { RelationalData } from './RelationalData.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_RelationalData(relationalData: RelationalData): T;
+  visit_RelationalCSVData(relationalData: RelationalCSVData): T;
 }
 
 export abstract class EmbeddedData implements Hashable {

package/src/models/metamodels/pure/data/{RelationalData.ts → RelationalCSVData.ts}

@@ -18,53 +18,30 @@ import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../MetaModelConst.js';
 import { type EmbeddedDataVisitor, EmbeddedData } from './EmbeddedData.js';
 
-export class RelationalDataTableColumn implements Hashable {
-  value!: string;
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE_COLUMN,
-      this.value,
-    ]);
-  }
-}
-export class RelationalDataTableRow implements Hashable {
+export class 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 RelationalDataTable implements Hashable {
-  schemaName: string | undefined;
-  tableName!: string;
-  columns: RelationalDataTableColumn[] = [];
-  rows: RelationalDataTableRow[] = [];
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE,
-      this.schemaName ?? '',
-      this.tableName,
-      hashArray(this.columns),
-      hashArray(this.rows),
-    ]);
-  }
-}
-export class RelationalData extends EmbeddedData implements Hashable {
-  tables: RelationalDataTable[] = [];
+export class RelationalCSVData extends EmbeddedData implements Hashable {
+  tables: RelationalCSVDataTable[] = [];
 
   accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
-    return visitor.visit_RelationalData(this);
+    return visitor.visit_RelationalCSVData(this);
   }
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE,
+      CORE_HASH_STRUCTURE.RELATIONAL_CSV_DATA_TABLE,
       hashArray(this.tables),
     ]);
   }

package/src/models/metamodels/pure/packageableElements/service/ServiceTest.ts

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

package/src/models/metamodels/pure/test/Test.ts

@@ -16,6 +16,7 @@
 
 import type { Hashable } from '@finos/legend-shared';
 import type { TestAssertion } from './assertion/TestAssertion.js';
+import type { Testable } from './Testable.js';
 
 export abstract class Test implements Hashable {
   id!: string;
@@ -24,13 +25,14 @@ export abstract class Test implements Hashable {
 }
 
 export abstract class AtomicTest extends Test implements Hashable {
-  __parentSuite: TestSuite | undefined;
+  __parent!: TestSuite | Testable;
   assertions: TestAssertion[] = [];
 
   abstract override get hashCode(): string;
 }
 
 export abstract class TestSuite extends Test implements Hashable {
+  __parent!: Testable;
   tests: AtomicTest[] = [];
 
   abstract override get hashCode(): string;

package/src/models/metamodels/pure/test/assertion/EqualToTDS.ts

@@ -14,29 +14,14 @@
  * 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 {
-  RelationalDataTableColumn,
-  RelationalDataTableRow,
-} from '../../data/RelationalData.js';
-import { type TestAssertionVisitor, TestAssertion } from './TestAssertion.js';
-
-export class RelationalTDS implements Hashable {
-  columns: RelationalDataTableColumn[] = [];
-  rows: RelationalDataTableRow[] = [];
+import type { ExternalFormatData } from '../../data/EmbeddedData.js';
 
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.RELATIONAL_TDS,
-      hashArray(this.columns),
-      hashArray(this.rows),
-    ]);
-  }
-}
+import { type TestAssertionVisitor, TestAssertion } from './TestAssertion.js';
 
 export class EqualToTDS extends TestAssertion {
-  expected!: RelationalTDS;
+  expected!: ExternalFormatData;
 
   get hashCode(): string {
     return hashArray([

package/src/models/protocols/pure/DSLExternalFormat_PureProtocolProcessorPlugin.ts

@@ -55,7 +55,8 @@ import {
   type V1_ElementProtocolDeserializer,
   type V1_ElementProtocolSerializer,
   type V1_ElementTransformer,
-  type V1_ExecutionInputGetter,
+  type V1_ExecutionInputCollector,
+  type V1_MappingModelCoverageAnalysisInputCollector,
   PureProtocolProcessorPlugin,
 } from './PureProtocolProcessorPlugin.js';
 import type { V1_PureModelContextData } from './v1/model/context/V1_PureModelContextData.js';
@@ -299,7 +300,7 @@ export class DSLExternalFormat_PureProtocolProcessorPlugin
     ];
   }
 
-  override V1_getExtraExecutionInputGetters(): V1_ExecutionInputGetter[] {
+  override V1_getExtraExecutionInputCollectors(): V1_ExecutionInputCollector[] {
     return [
       (
         graph: PureModel,
@@ -313,6 +314,18 @@ export class DSLExternalFormat_PureProtocolProcessorPlugin
     ];
   }
 
+  override V1_getExtraMappingModelCoverageAnalysisInputCollectors(): V1_MappingModelCoverageAnalysisInputCollector[] {
+    return [
+      (
+        graph: PureModel,
+        protocolGraph: V1_PureModelContextData,
+      ): V1_PackageableElement[] =>
+        protocolGraph.elements.filter(
+          (element) => element instanceof V1_SchemaSet,
+        ),
+    ];
+  }
+
   V1_getExtraConnectionBuilders(): V1_ConnectionBuilder[] {
     return [
       (