@finos/legend-graph 4.0.2 → 6.0.0

package/src/models/metamodels/pure/packageableElements/mapping/SetImplementation.ts

@@ -15,15 +15,10 @@
  */
 
 import { hashArray, type Hashable } from '@finos/legend-shared';
-import { fromElementPathToMappingElementId } from '../../../../../MetaModelUtils';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
-import {
-  PackageableElementExplicitReference,
-  type PackageableElementReference,
-} from '../PackageableElementReference';
+import type { PackageableElementReference } from '../PackageableElementReference';
 import type { PropertyOwnerImplementation } from './PropertyOwnerImplementation';
-import { Class } from '../domain/Class';
-import type { Mapping, MappingElementLabel } from './Mapping';
+import type { Mapping } from './Mapping';
 import type { Stubable } from '../../../../../helpers/Stubable';
 import type { OperationSetImplementation } from './OperationSetImplementation';
 import type { PureInstanceSetImplementation } from '../store/modelToModel/mapping/PureInstanceSetImplementation';
@@ -31,17 +26,13 @@ import type { FlatDataInstanceSetImplementation } from '../store/flatData/mappin
 import type { EmbeddedFlatDataPropertyMapping } from '../store/flatData/mapping/EmbeddedFlatDataPropertyMapping';
 import type { RelationalInstanceSetImplementation } from '../store/relational/mapping/RelationalInstanceSetImplementation';
 import type { RootRelationalInstanceSetImplementation } from '../store/relational/mapping/RootRelationalInstanceSetImplementation';
-import {
-  InferableMappingElementIdExplicitValue,
-  type InferableMappingElementIdValue,
-} from './InferableMappingElementId';
-import {
-  InferableMappingElementRootExplicitValue,
-  type InferableMappingElementRoot,
-} from './InferableMappingElementRoot';
+import type { InferableMappingElementIdValue } from './InferableMappingElementId';
+import type { InferableMappingElementRoot } from './InferableMappingElementRoot';
 import type { AggregationAwareSetImplementation } from './aggregationAware/AggregationAwareSetImplementation';
 import type { InstanceSetImplementation } from './InstanceSetImplementation';
 import type { MergeOperationSetImplementation } from './MergeOperationSetImplementation';
+import type { TEMPORARY__UnresolvedSetImplementation } from './TEMPORARY__UnresolvedSetImplementation';
+import type { Class } from '../domain/Class';
 
 export interface SetImplementationVisitor<T> {
   visit_SetImplementation(setImplementation: InstanceSetImplementation): T;
@@ -78,11 +69,11 @@ export interface SetImplementationVisitor<T> {
 export abstract class SetImplementation
   implements PropertyOwnerImplementation, Hashable, Stubable
 {
+  readonly parent: Mapping;
   readonly isEmbedded: boolean = false;
   id: InferableMappingElementIdValue;
   class: PackageableElementReference<Class>;
   root: InferableMappingElementRoot;
-  parent: Mapping;
 
   constructor(
     id: InferableMappingElementIdValue,
@@ -96,21 +87,6 @@ export abstract class SetImplementation
     this.root = root;
   }
 
-  get label(): MappingElementLabel {
-    return {
-      value: `${
-        fromElementPathToMappingElementId(this.class.value.path) ===
-        this.id.value
-          ? this.root.value
-            ? this.class.value.name
-            : `${this.class.value.name} [default]`
-          : `${this.class.value.name} [${this.id.value}]`
-      }`,
-      root: this.root.value,
-      tooltip: this.class.value.path,
-    };
-  }
-
   get isStub(): boolean {
     return !this.id.value;
   }
@@ -129,11 +105,13 @@ export abstract class SetImplementation
   ): T;
 }
 
+// TODO: to be moved out of metamodel
 export enum BASIC_SET_IMPLEMENTATION_TYPE {
   OPERATION = 'operation',
   INSTANCE = 'instance',
 }
 
+// TODO: to be moved out of metamodel
 export enum SET_IMPLEMENTATION_TYPE {
   OPERATION = 'operation',
   MERGE_OPERATION = 'mergeOperation',
@@ -144,29 +122,3 @@ export enum SET_IMPLEMENTATION_TYPE {
   EMBEDDED_RELATIONAL = 'embeddedRelational',
   AGGREGATION_AWARE = 'aggregationAware',
 }
-
-/* @MARKER: RELAXED GRAPH CHECK - See https://github.com/finos/legend-studio/issues/941 */
-/**
- * When set implementation cannot be resolved by ID,
- * we try to avoid failing graph building for now
- * instead, we will leave this loose end unresolved.
- *
- * NOTE: this is just a temporary solutions until we make this a hard-fail post migration.
- *
- * See https://github.com/finos/legend-studio/issues/880
- * See https://github.com/finos/legend-studio/issues/941
- */
-export class TEMPORARY__UnresolvedSetImplementation extends SetImplementation {
-  constructor(id: string, parent: Mapping) {
-    super(
-      InferableMappingElementIdExplicitValue.create(id, ''),
-      parent,
-      PackageableElementExplicitReference.create(new Class('')),
-      InferableMappingElementRootExplicitValue.create(false),
-    );
-  }
-
-  accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
-    return visitor.visit_TEMPORARY__UnresolvedSetImplementation(this);
-  }
-}

package/src/models/metamodels/pure/packageableElements/mapping/TEMPORARY__UnresolvedSetImplementation.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 { Class } from '../domain/Class';
+import { PackageableElementExplicitReference } from '../PackageableElementReference';
+import { InferableMappingElementIdExplicitValue } from './InferableMappingElementId';
+import { InferableMappingElementRootExplicitValue } from './InferableMappingElementRoot';
+import type { Mapping } from './Mapping';
+import {
+  SetImplementation,
+  type SetImplementationVisitor,
+} from './SetImplementation';
+
+/**
+ * When set implementation cannot be resolved by ID,
+ * we try to avoid failing graph building for now
+ * instead, we will leave this loose end unresolved.
+ *
+ * NOTE: this is just a temporary solutions until we make this a hard-fail post migration.
+ *
+ * See https://github.com/finos/legend-studio/issues/880
+ * See https://github.com/finos/legend-studio/issues/941
+ *
+ * @discrepancy graph-building
+ */
+export class TEMPORARY__UnresolvedSetImplementation extends SetImplementation {
+  constructor(id: string, parent: Mapping) {
+    super(
+      InferableMappingElementIdExplicitValue.create(id, ''),
+      parent,
+      PackageableElementExplicitReference.create(new Class('')),
+      InferableMappingElementRootExplicitValue.create(false),
+    );
+  }
+
+  accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
+    return visitor.visit_TEMPORARY__UnresolvedSetImplementation(this);
+  }
+}

package/src/models/metamodels/pure/packageableElements/mapping/aggregationAware/AggregationFunctionSpecification.ts

@@ -20,8 +20,18 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../MetaModelConst';
 import { hashLambda } from '../../../../../../MetaModelUtils';
 
 export class AggregationFunctionSpecification implements Hashable {
-  mapFn: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
-  aggregateFn: 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
+   */
+  mapFn: RawLambda;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  aggregateFn: RawLambda;
 
   constructor(mapFn: RawLambda, aggregateFn: RawLambda) {
     this.mapFn = mapFn;

package/src/models/metamodels/pure/packageableElements/mapping/aggregationAware/GroupByFunctionSpecification.ts

@@ -20,7 +20,12 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../MetaModelConst';
 import { hashLambda } from '../../../../../../MetaModelUtils';
 
 export class GroupByFunctionSpecification implements Hashable {
-  groupByFn: 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
+   */
+  groupByFn: RawLambda;
 
   constructor(groupByFn: RawLambda) {
     this.groupByFn = groupByFn;

package/src/models/metamodels/pure/packageableElements/mapping/xStore/XStorePropertyMapping.ts

@@ -27,7 +27,12 @@ export class XStorePropertyMapping
   extends PropertyMapping
   implements Hashable, Stubable
 {
-  crossExpression!: 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
+   */
+  crossExpression!: RawLambda;
 
   override get hashCode(): string {
     return hashArray([

package/src/models/metamodels/pure/packageableElements/section/Section.ts

@@ -21,13 +21,8 @@ import type { Package } from '../domain/Package';
 import type { SectionIndex } from './SectionIndex';
 import type { PackageableElementExplicitReference } from '../PackageableElementReference';
 
-export enum SectionType {
-  IMPORT_AWARE = 'importAware',
-  DEFAULT = 'default',
-}
-
 export abstract class Section implements Hashable {
-  parent: SectionIndex;
+  readonly parent: SectionIndex;
   parserName: string;
   elements: PackageableElementExplicitReference<PackageableElement>[] = [];
 

package/src/models/metamodels/pure/packageableElements/service/ConnectionTestData.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 { EmbeddedData } from '../../data/EmbeddedData';
+
+export class ConnectionTestData implements Hashable {
+  connectionId!: string;
+  testData!: EmbeddedData;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_CONNECTION_TEST_DATA,
+      this.connectionId,
+      this.testData,
+    ]);
+  }
+}

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

@@ -0,0 +1,132 @@
+/**
+ * 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, hashArray, uuid } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+import type { RawLambda } from '../../rawValueSpecification/RawLambda';
+import type { Service } from './Service';
+
+/**
+ * TODO: Remove once migration from `ServiceTest_Legacy` to `ServiceTest` is complete
+ * @deprecated
+ */
+export abstract class DEPRECATED__ServiceTest implements Hashable {
+  owner: Service;
+
+  constructor(owner: Service) {
+    this.owner = owner;
+  }
+
+  abstract get hashCode(): string;
+}
+
+/**
+ * TODO: Remove once migration from `ServiceTest_Legacy` to `ServiceTest` is complete
+ * @deprecated
+ */
+export class DEPRECATED__TestContainer implements Hashable {
+  readonly uuid = uuid();
+
+  parametersValues: unknown[] = []; // Any[*]; // ValueSpecification?
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  assert: RawLambda;
+  singleExecutionTestParent: DEPRECATED__SingleExecutionTest;
+
+  constructor(assert: RawLambda, parent: DEPRECATED__SingleExecutionTest) {
+    this.assert = assert;
+    this.singleExecutionTestParent = parent;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_TEST_CONTAINER,
+      // this.parameterValues,
+      this.assert,
+    ]);
+  }
+}
+
+/**
+ * TODO: Remove once migration from `ServiceTest_Legacy` to `ServiceTest` is complete
+ * @deprecated
+ */
+export class DEPRECATED__SingleExecutionTest
+  extends DEPRECATED__ServiceTest
+  implements Hashable
+{
+  data: string;
+  asserts: DEPRECATED__TestContainer[] = [];
+
+  constructor(owner: Service, data: string) {
+    super(owner);
+    this.data = data;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_LEGACY_SINGLE_EXECUTION_TEST,
+      this.data,
+      hashArray(this.asserts),
+    ]);
+  }
+}
+
+/**
+ * TODO: Remove once migration from `ServiceTest_Legacy` to `ServiceTest` is complete
+ * @deprecated
+ */
+export class DEPRECATED__KeyedSingleExecutionTest
+  extends DEPRECATED__SingleExecutionTest
+  implements Hashable
+{
+  key: string;
+
+  constructor(key: string, parentService: Service, data: string) {
+    super(parentService, data);
+    this.key = key;
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_LEGACY_KEYED_SINGLE_EXECUTION_TEST,
+      this.key,
+      this.data,
+      hashArray(this.asserts),
+    ]);
+  }
+}
+
+/**
+ * TODO: Remove once migration from `ServiceTest_Legacy` to `ServiceTest` is complete
+ * @deprecated
+ */
+export class DEPRECATED__MultiExecutionTest
+  extends DEPRECATED__ServiceTest
+  implements Hashable
+{
+  tests: DEPRECATED__KeyedSingleExecutionTest[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_LEGACY_MULTI_EXECUTION_TEST,
+      hashArray(this.tests),
+    ]);
+  }
+}

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

@@ -0,0 +1,37 @@
+/**
+ * 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';
+
+export class ParameterValue implements Hashable {
+  name!: string;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  value!: object;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_PARAMETER_VALUE,
+      this.name,
+      hashObjectWithoutSourceInformation(this.value),
+    ]);
+  }
+}

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

@@ -17,13 +17,14 @@
 import { hashArray, uniq, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import type { ServiceExecution } from './ServiceExecution';
-import { type ServiceTest, SingleExecutionTest } from './ServiceTest';
 import {
   type PackageableElementVisitor,
   PackageableElement,
 } from '../PackageableElement';
 import type { StereotypeReference } from '../domain/StereotypeReference';
 import type { TaggedValue } from '../domain/TaggedValue';
+import type { DEPRECATED__ServiceTest } from './DEPRECATED__ServiceTest';
+import type { ServiceTestSuite } from './ServiceTestSuite';
 
 export const DEFAULT_SERVICE_PATTERN = '/';
 
@@ -35,12 +36,9 @@ export class Service extends PackageableElement implements Hashable {
   documentation = '';
   autoActivateUpdates = true;
   execution!: ServiceExecution;
-  test: ServiceTest;
+  test?: DEPRECATED__ServiceTest | undefined;
+  tests: ServiceTestSuite[] = [];
 
-  constructor(name: string) {
-    super(name);
-    this.test = new SingleExecutionTest(this, '');
-  }
   get patternParameters(): string[] {
     return uniq(
       (this.pattern.match(/\{\w+\}/gu) ?? []).map((parameter) =>
@@ -62,7 +60,8 @@ export class Service extends PackageableElement implements Hashable {
       this.documentation,
       this.autoActivateUpdates.toString(),
       this.execution,
-      this.test,
+      this.test ?? '',
+      hashArray(this.tests),
     ]);
   }
 

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

@@ -27,14 +27,17 @@ import {
 import type { PackageableElementReference } from '../PackageableElementReference';
 
 export abstract class ServiceExecution implements Hashable {
-  private readonly _$nominalTypeBrand!: 'ServiceExecution';
-
   abstract get hashCode(): string;
 }
 
 export class PureExecution extends ServiceExecution implements Hashable {
   owner: Service;
-  func: 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
+   */
+  func: RawLambda;
 
   constructor(func: RawLambda, owner: Service) {
     super();

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

@@ -14,88 +14,20 @@
  * limitations under the License.
  */
 
-import { type Hashable, uuid, hashArray } from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
-import type { RawLambda } from '../../rawValueSpecification/RawLambda';
-import type { Service } from './Service';
+import { AtomicTest } from '../../test/Test';
+import type { ParameterValue } from './ParameterValue';
 
-export abstract class ServiceTest implements Hashable {
-  owner: Service;
-
-  constructor(owner: Service) {
-    this.owner = owner;
-  }
-
-  abstract get hashCode(): string;
-}
-
-export class TestContainer implements Hashable {
-  readonly uuid = uuid();
-
-  parametersValues: unknown[] = []; // Any[*]; // ValueSpecification?
-  assert: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
-  singleExecutionTestParent: SingleExecutionTest;
-
-  constructor(assert: RawLambda, parent: SingleExecutionTest) {
-    this.assert = assert;
-    this.singleExecutionTestParent = parent;
-  }
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.SERVICE_TEST_CONTAINER,
-      // this.parameterValues,
-      this.assert,
-    ]);
-  }
-}
-
-export class SingleExecutionTest extends ServiceTest implements Hashable {
-  data: string;
-  asserts: TestContainer[] = [];
-
-  constructor(owner: Service, data: string) {
-    super(owner);
-    this.data = data;
-  }
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.SERVICE_SINGLE_EXECUTION_TEST,
-      this.data,
-      hashArray(this.asserts),
-    ]);
-  }
-}
-
-export class KeyedSingleExecutionTest
-  extends SingleExecutionTest
-  implements Hashable
-{
-  key: string;
-
-  constructor(key: string, parentService: Service, data: string) {
-    super(parentService, data);
-    this.key = key;
-  }
-
-  override get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.SERVICE_KEYED_SINGLE_EXECUTION_TEST,
-      this.key,
-      this.data,
-      hashArray(this.asserts),
-    ]);
-  }
-}
-
-export class MultiExecutionTest extends ServiceTest implements Hashable {
-  tests: KeyedSingleExecutionTest[] = [];
+export class ServiceTest extends AtomicTest implements Hashable {
+  parameters: ParameterValue[] = [];
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.SERVICE_MULTI_EXECUTION_TEST,
-      hashArray(this.tests),
+      CORE_HASH_STRUCTURE.SERVICE_TEST,
+      this.id,
+      hashArray(this.assertions),
+      hashArray(this.parameters),
     ]);
   }
 }

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

@@ -0,0 +1,30 @@
+/**
+ * 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 { ConnectionTestData } from './ConnectionTestData';
+
+export class TestData implements Hashable {
+  connectionsTestData: ConnectionTestData[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_TEST_DATA,
+      hashArray(this.connectionsTestData),
+    ]);
+  }
+}

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

@@ -0,0 +1,33 @@
+/**
+ * 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 { TestSuite } from '../../test/Test';
+import type { TestData } from './ServiceTestData';
+
+export class ServiceTestSuite extends TestSuite implements Hashable {
+  testData!: TestData;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_TEST_SUITE,
+      this.id,
+      hashArray(this.tests),
+      this.testData,
+    ]);
+  }
+}