@finos/legend-graph 4.0.2 → 6.0.0

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/EmbeddedFlatDataPropertyMapping.ts

@@ -14,13 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  hashArray,
-  UnsupportedOperationError,
-  type Hashable,
-} from '@finos/legend-shared';
+import { filterByType, hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
-import type { Mapping, MappingElementLabel } from '../../../mapping/Mapping';
+import type { Mapping } from '../../../mapping/Mapping';
 import { AbstractFlatDataPropertyMapping } from './AbstractFlatDataPropertyMapping';
 import type {
   PropertyMapping,
@@ -37,6 +33,7 @@ import type { PropertyReference } from '../../../domain/PropertyReference';
 import type { InferableMappingElementIdValue } from '../../../mapping/InferableMappingElementId';
 import type { PackageableElementReference } from '../../../PackageableElementReference';
 import { InferableMappingElementRootExplicitValue } from '../../../mapping/InferableMappingElementRoot';
+import type { MappingClass } from '../../../mapping/MappingClass';
 
 /**
  * We can think of embedded property mappings as a 'gateway' from one set of property mappings to another. They are in a sense
@@ -59,7 +56,8 @@ export class EmbeddedFlatDataPropertyMapping
   id: InferableMappingElementIdValue;
   propertyMappings: PropertyMapping[] = [];
   rootInstanceSetImplementation: InstanceSetImplementation; // in Pure we call this `setMappingOwner`
-  parent: Mapping;
+  readonly parent: Mapping;
+  mappingClass?: MappingClass | undefined;
 
   constructor(
     owner: PropertyMappingsImplementation,
@@ -77,18 +75,6 @@ export class EmbeddedFlatDataPropertyMapping
     this.parent = rootInstanceSetImplementation.parent;
   }
 
-  setRoot(value: boolean): void {
-    throw new UnsupportedOperationError();
-  }
-
-  get label(): MappingElementLabel {
-    return {
-      value: `${this.class.value.name} [${this.property.value.name}]`,
-      root: this.root.value,
-      tooltip: this.class.value.path,
-    };
-  }
-
   // As of now, there is no stub cases of Embedded Flat Property Mapping since they are created with an existing property mapping
   override get isStub(): boolean {
     return false;
@@ -119,8 +105,7 @@ export class EmbeddedFlatDataPropertyMapping
 
   getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
     const embeddedPropertyMappings = this.propertyMappings.filter(
-      (propertyMapping): propertyMapping is EmbeddedFlatDataPropertyMapping =>
-        propertyMapping instanceof EmbeddedFlatDataPropertyMapping,
+      filterByType(EmbeddedFlatDataPropertyMapping),
     );
     return embeddedPropertyMappings
       .map((embeddedPropertyMapping) =>

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/FlatDataInstanceSetImplementation.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { hashArray, type Hashable } from '@finos/legend-shared';
+import { filterByType, hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import { InstanceSetImplementation } from '../../../mapping/InstanceSetImplementation';
 import type { AbstractFlatDataPropertyMapping } from './AbstractFlatDataPropertyMapping';
@@ -33,7 +33,12 @@ export class FlatDataInstanceSetImplementation
   implements Hashable
 {
   sourceRootRecordType: RootFlatDataRecordTypeReference;
-  filter?: RawLambda | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  filter?: RawLambda | undefined;
   declare propertyMappings: AbstractFlatDataPropertyMapping[];
 
   constructor(
@@ -67,10 +72,7 @@ export class FlatDataInstanceSetImplementation
 
   getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
     const embeddedPropertyMappings = this.propertyMappings.filter(
-      (
-        propertyMapping: AbstractFlatDataPropertyMapping,
-      ): propertyMapping is EmbeddedFlatDataPropertyMapping =>
-        propertyMapping instanceof EmbeddedFlatDataPropertyMapping,
+      filterByType(EmbeddedFlatDataPropertyMapping),
     );
     return embeddedPropertyMappings
       .map((propertyMapping) => propertyMapping.getEmbeddedSetImplmentations())

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/FlatDataPropertyMapping.ts

@@ -30,7 +30,12 @@ export class FlatDataPropertyMapping
 {
   // TODO: convert to reference
   transformer?: EnumerationMapping | undefined;
-  transform: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  transform: RawLambda;
 
   constructor(
     owner: PropertyMappingsImplementation,

package/src/models/metamodels/pure/packageableElements/store/modelToModel/mapping/ObjectInputData.ts

@@ -61,7 +61,9 @@ export class ObjectInputData extends InputData implements Hashable {
     super();
     this.sourceClass = sourceClass;
     this.inputType = inputType;
-    /* @MARKER: Workaround for https://github.com/finos/legend-studio/issues/66 */
+    /**
+     * @workaround https://github.com/finos/legend-studio/issues/68
+     */
     this.data =
       inputType === ObjectInputType.JSON
         ? tryToMinifyLosslessJSONString(data)

package/src/models/metamodels/pure/packageableElements/store/modelToModel/mapping/PureInstanceSetImplementation.ts

@@ -39,7 +39,12 @@ export class PureInstanceSetImplementation
 {
   declare propertyMappings: PurePropertyMapping[];
   srcClass: OptionalPackageableElementReference<Class>;
-  filter?: RawLambda | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  filter?: RawLambda | undefined;
 
   constructor(
     id: InferableMappingElementIdValue,

package/src/models/metamodels/pure/packageableElements/store/modelToModel/mapping/PurePropertyMapping.ts

@@ -33,7 +33,12 @@ export class PurePropertyMapping
 {
   // TODO: convert to reference
   transformer?: EnumerationMapping | undefined;
-  transform: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  transform: RawLambda;
   explodeProperty?: boolean | undefined;
 
   constructor(

package/src/models/metamodels/pure/packageableElements/store/relational/connection/AuthenticationStrategy.ts

@@ -18,8 +18,6 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import { type Hashable, hashArray } from '@finos/legend-shared';
 
 export abstract class AuthenticationStrategy implements Hashable {
-  private readonly _$nominalTypeBrand!: 'AuthenticationStrategy';
-
   abstract get hashCode(): string;
 }
 

package/src/models/metamodels/pure/packageableElements/store/relational/connection/DatasourceSpecification.ts

@@ -18,8 +18,6 @@ import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 
 export abstract class DatasourceSpecification implements Hashable {
-  private readonly _$nominalTypeBrand!: 'DatasourceSpecification';
-
   abstract get hashCode(): string;
 }
 

package/src/models/metamodels/pure/packageableElements/store/relational/connection/RelationalDatabaseConnection.ts

@@ -26,6 +26,8 @@ import type { Database } from '../model/Database';
 import type { PackageableElementReference } from '../../../PackageableElementReference';
 import type { PostProcessor } from './postprocessor/PostProcessor';
 
+// TODO: to be modularized or handled differently
+// See https://github.com/finos/legend-studio/issues/946
 export enum DatabaseType {
   DB2 = 'DB2',
   H2 = 'H2',

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/EmbeddedRelationalInstanceSetImplementation.ts

@@ -23,7 +23,7 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import type { RelationalOperationElement } from '../model/RelationalOperationElement';
 import type { EmbeddedSetImplementation } from '../../../mapping/EmbeddedSetImplementation';
 import type { Class } from '../../../domain/Class';
-import type { Mapping, MappingElementLabel } from '../../../mapping/Mapping';
+import type { Mapping } from '../../../mapping/Mapping';
 import type {
   SetImplementationVisitor,
   SetImplementation,
@@ -40,6 +40,7 @@ import type { PackageableElementReference } from '../../../PackageableElementRef
 import type { PropertyReference } from '../../../domain/PropertyReference';
 import type { RelationalInstanceSetImplementation } from './RelationalInstanceSetImplementation';
 import { InferableMappingElementRootExplicitValue } from '../../../mapping/InferableMappingElementRoot';
+import type { MappingClass } from '../../../mapping/MappingClass';
 
 export class EmbeddedRelationalInstanceSetImplementation
   extends PropertyMapping
@@ -54,8 +55,9 @@ export class EmbeddedRelationalInstanceSetImplementation
   propertyMappings: PropertyMapping[] = [];
   class: PackageableElementReference<Class>;
   rootInstanceSetImplementation: RootRelationalInstanceSetImplementation; // in Pure we call this `setMappingOwner`
-  parent: Mapping;
   primaryKey: RelationalOperationElement[] = [];
+  readonly parent: Mapping;
+  mappingClass?: MappingClass | undefined;
 
   constructor(
     owner: PropertyMappingsImplementation,
@@ -73,10 +75,6 @@ export class EmbeddedRelationalInstanceSetImplementation
     this.parent = rootInstanceSetImplementation.parent;
   }
 
-  setRoot(value: boolean): void {
-    throw new UnsupportedOperationError();
-  }
-
   getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
     throw new UnsupportedOperationError();
   }
@@ -99,10 +97,6 @@ export class EmbeddedRelationalInstanceSetImplementation
     );
   }
 
-  get label(): MappingElementLabel {
-    throw new UnsupportedOperationError();
-  }
-
   override get isStub(): boolean {
     return false;
   }

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/RelationalInstanceSetImplementation.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { type Hashable, hashArray } from '@finos/legend-shared';
+import { type Hashable, hashArray, filterByType } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import { InstanceSetImplementation } from '../../../mapping/InstanceSetImplementation';
 import type { SetImplementationVisitor } from '../../../mapping/SetImplementation';
@@ -30,10 +30,7 @@ export class RelationalInstanceSetImplementation
 
   getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
     const embeddedPropertyMappings = this.propertyMappings.filter(
-      (
-        propertyMapping: PropertyMapping,
-      ): propertyMapping is EmbeddedRelationalInstanceSetImplementation =>
-        propertyMapping instanceof EmbeddedRelationalInstanceSetImplementation,
+      filterByType(EmbeddedRelationalInstanceSetImplementation),
     );
     return embeddedPropertyMappings
       .map((propertyMapping) => propertyMapping.getEmbeddedSetImplmentations())

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/RelationalPropertyMapping.ts

@@ -34,7 +34,12 @@ export class RelationalPropertyMapping
 {
   // TODO: convert to reference
   transformer?: EnumerationMapping | undefined;
-  relationalOperation!: RawRelationalOperationElement; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process relational operation element
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  relationalOperation!: RawRelationalOperationElement;
   bindingTransformer?: BindingTransformer | undefined;
 
   accept_PropertyMappingVisitor<T>(visitor: PropertyMappingVisitor<T>): T {

package/src/models/metamodels/pure/packageableElements/store/relational/model/RawRelationalOperationElement.ts

@@ -16,7 +16,12 @@
 
 import { isEmpty } from '@finos/legend-shared';
 
-export type RawRelationalOperationElement = object; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process relational operation element
+/**
+ * Studio does not process value specification, they are left in raw JSON form
+ *
+ * @discrepancy model
+ */
+export type RawRelationalOperationElement = object;
 
 export const createStubRelationalOperationElement =
   (): RawRelationalOperationElement => ({});

package/src/models/metamodels/pure/packageableElements/store/relational/model/RelationalOperationElement.ts

@@ -30,8 +30,6 @@ import type { Database } from './Database';
 import { SELF_JOIN_TABLE_NAME } from './Join';
 
 export abstract class RelationalOperationElement {
-  private readonly _$nominalTypeBrand!: 'RelationalOperationElement';
-
   abstract get hashCode(): string;
 }
 

package/src/models/metamodels/pure/packageableElements/store/relational/model/Table.ts

@@ -19,6 +19,7 @@ import {
   type Hashable,
   hashArray,
   guaranteeNonNullable,
+  filterByType,
 } from '@finos/legend-shared';
 import { NamedRelation } from './RelationalOperationElement';
 import type { Schema } from './Schema';
@@ -38,10 +39,9 @@ export class Table extends NamedRelation implements Hashable {
 
   getColumn = (name: string): Column =>
     guaranteeNonNullable(
-      this.columns.find(
-        (column): column is Column =>
-          column instanceof Column && column.name === name,
-      ),
+      this.columns
+        .filter(filterByType(Column))
+        .find((column) => column.name === name),
       `Can't find column '${name}' in table '${this.name}'`,
     );
 

package/src/models/metamodels/pure/packageableElements/store/relational/model/View.ts

@@ -18,6 +18,7 @@ import {
   type Hashable,
   hashArray,
   guaranteeNonNullable,
+  filterByType,
 } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import type { ColumnMapping } from './ColumnMapping';
@@ -48,10 +49,9 @@ export class View
 
   getColumn = (name: string): Column =>
     guaranteeNonNullable(
-      this.columns.find(
-        (column): column is Column =>
-          column instanceof Column && column.name === name,
-      ),
+      this.columns
+        .filter(filterByType(Column))
+        .find((column) => column.name === name),
       `Can't find column '${name}' in table '${this.name}'`,
     );
 

package/src/models/metamodels/pure/packageableElements/store/relational/model/milestoning/Milestoning.ts

@@ -15,12 +15,12 @@
  */
 
 import type { Hashable } from '@finos/legend-shared';
-import type { RawInstanceValue } from '../../../../../rawValueSpecification/RawInstanceValue';
+import type { RawPrimitiveInstanceValue } from '../../../../../rawValueSpecification/RawPrimitiveInstanceValue';
 
 export abstract class Milestoning implements Hashable {
   abstract get hashCode(): string;
 }
 
 export abstract class TemporalMilestoning extends Milestoning {
-  infinityDate?: RawInstanceValue | undefined;
+  infinityDate?: RawPrimitiveInstanceValue | undefined;
 }

package/src/models/metamodels/pure/rawValueSpecification/{RawInstanceValue.ts → RawPrimitiveInstanceValue.ts}

@@ -24,7 +24,7 @@ import {
 } from './RawValueSpecification';
 import { CORE_HASH_STRUCTURE } from '../../../../MetaModelConst';
 
-export class RawInstanceValue
+export class RawPrimitiveInstanceValue
   extends RawValueSpecification
   implements Hashable
 {
@@ -57,6 +57,6 @@ export class RawInstanceValue
   accept_RawValueSpecificationVisitor<T>(
     visitor: RawValueSpecificationVisitor<T>,
   ): T {
-    return visitor.visit_RawInstanceValue(this);
+    return visitor.visit_RawPrimitiveInstanceValue(this);
   }
 }

package/src/models/metamodels/pure/rawValueSpecification/RawValueSpecification.ts

@@ -16,12 +16,14 @@
 
 import type { RawVariableExpression } from './RawVariableExpression';
 import type { RawLambda } from './RawLambda';
-import type { RawInstanceValue } from './RawInstanceValue';
+import type { RawPrimitiveInstanceValue } from './RawPrimitiveInstanceValue';
 
 export interface RawValueSpecificationVisitor<T> {
   visit_RawLambda(valueSpecification: RawLambda): T;
   visit_RawVariableExpression(valueSpecification: RawVariableExpression): T;
-  visit_RawInstanceValue(valueSpecification: RawInstanceValue): T;
+  visit_RawPrimitiveInstanceValue(
+    valueSpecification: RawPrimitiveInstanceValue,
+  ): T;
 }
 
 export abstract class RawValueSpecification {

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

@@ -0,0 +1,40 @@
+/**
+ * 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 { Hashable } from '@finos/legend-shared';
+import type { TestAssertion } from './assertion/TestAssertion';
+
+export interface Testable {
+  tests: Test[];
+}
+
+export abstract class Test implements Hashable {
+  id!: string;
+
+  abstract get hashCode(): string;
+}
+
+export abstract class AtomicTest extends Test implements Hashable {
+  assertions: TestAssertion[] = [];
+
+  abstract override get hashCode(): string;
+}
+
+export abstract class TestSuite extends Test implements Hashable {
+  tests: AtomicTest[] = [];
+
+  abstract override get hashCode(): string;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * 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 } from '../../../../../MetaModelConst';
+import { hashObjectWithoutSourceInformation } from '../../../../../MetaModelUtils';
+import { TestAssertion } from './TestAssertion';
+
+export class EqualTo extends TestAssertion implements Hashable {
+  expected!: object;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EQUAL_TO,
+      this.id,
+      hashObjectWithoutSourceInformation(this.expected),
+    ]);
+  }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * 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 } from '../../../../../MetaModelConst';
+import type { ExternalFormatData } from '../../data/EmbeddedData';
+import { TestAssertion } from './TestAssertion';
+
+export class EqualToJson extends TestAssertion implements Hashable {
+  expected!: ExternalFormatData;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EQUAL_TO_JSON,
+      this.id,
+      this.expected,
+    ]);
+  }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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 { Hashable } from '@finos/legend-shared';
+
+export interface TestAssertionVisitor<T> {
+  visit_TestAssertion(testAssertion: TestAssertion): T;
+}
+
+export abstract class TestAssertion implements Hashable {
+  id!: string;
+
+  abstract get hashCode(): string;
+
+  accept_TestAssertionVisitor<T>(visitor: TestAssertionVisitor<T>): T {
+    return visitor.visit_TestAssertion(this);
+  }
+}

package/src/models/metamodels/pure/test/assertion/status/AssertFail.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 } from '../../../../../../MetaModelConst';
+import { AssertionStatus } from './AssertionStatus';
+
+export class AssertFail extends AssertionStatus implements Hashable {
+  message!: string;
+
+  get hashCode(): string {
+    return hashArray([CORE_HASH_STRUCTURE.ASSERT_FAIL, this.id, this.message]);
+  }
+}

package/src/models/metamodels/pure/test/assertion/status/AssertPass.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 } from '../../../../../../MetaModelConst';
+import { AssertionStatus } from './AssertionStatus';
+
+export class AssertPass extends AssertionStatus implements Hashable {
+  get hashCode(): string {
+    return hashArray([CORE_HASH_STRUCTURE.ASSERT_PASS, this.id]);
+  }
+}

package/src/models/metamodels/pure/test/assertion/status/AssertionStatus.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { Hashable } from '@finos/legend-shared';
+
+export abstract class AssertionStatus implements Hashable {
+  id!: string;
+
+  abstract get hashCode(): string;
+}

package/src/models/metamodels/pure/test/assertion/status/EqualToJsonAssertFail.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 } from '../../../../../../MetaModelConst';
+import { AssertFail } from './AssertFail';
+
+export class EqualToJsonAssertFail extends AssertFail implements Hashable {
+  expected!: string;
+  actual!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EQUAL_TO_JSON_ASSERT_FAIL,
+      this.id,
+      this.message,
+      this.expected,
+      this.actual,
+    ]);
+  }
+}