@finos/legend-graph 9.0.1 → 10.0.0

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/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

@@ -218,7 +218,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 +296,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 +321,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 [
       (

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

@@ -58,13 +58,18 @@ export type V1_FunctionExpressionBuilder = (
   processingContext: V1_ProcessingContext,
 ) => [SimpleFunctionExpression, ValueSpecification[]] | undefined;
 
-export type V1_ExecutionInputGetter = (
+export type V1_ExecutionInputCollector = (
   graph: PureModel,
   mapping: Mapping,
   runtime: Runtime,
   protocolGraph: V1_PureModelContextData,
 ) => V1_PackageableElement[];
 
+export type V1_MappingModelCoverageAnalysisInputCollector = (
+  graph: PureModel,
+  protocolGraph: V1_PureModelContextData,
+) => V1_PackageableElement[];
+
 export type V1_PropertyExpressionTypeInferrer = (
   variable: ValueSpecification | undefined,
 ) => Type | undefined;
@@ -141,7 +146,16 @@ export abstract class PureProtocolProcessorPlugin extends AbstractPlugin {
    * We prune the graph to avoid sending the server additional elements not needed for execution.
    * This would provide a mechanism to add more elements in this reduced graph.
    */
-  V1_getExtraExecutionInputGetters?(): V1_ExecutionInputGetter[];
+  V1_getExtraExecutionInputCollectors?(): V1_ExecutionInputCollector[];
+
+  /**
+   * Get the list of collectors of graph elements to build mapping-model-coverage-analysis input.
+   *
+   * In particular, such collector is used to specify any additional packageable elements
+   * added to the graph that is used when analyzing mapped properties in the mapping.
+   * This would provide a mechanism to add more elements in this reduced graph.
+   */
+  V1_getExtraMappingModelCoverageAnalysisInputCollectors?(): V1_MappingModelCoverageAnalysisInputCollector[];
 
   /**
    * Get the list of type inferrers for property expression.