@finos/legend-graph 5.0.0 → 6.0.0

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

@@ -28,7 +28,12 @@ export class MappingTest implements Hashable {
   readonly uuid = uuid();
 
   name: string;
-  query: 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
+   */
+  query: RawLambda;
   inputData: InputData[] = [];
   assert: MappingTestAssert;
 

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

@@ -24,7 +24,6 @@ import {
   type SetImplementationVisitor,
 } from './SetImplementation';
 
-/* @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
@@ -34,6 +33,8 @@ import {
  *
  * 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) {

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

@@ -32,7 +32,12 @@ export abstract class ServiceExecution implements Hashable {
 
 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,
+    ]);
+  }
+}

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

@@ -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(

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/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/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;
+}