@finos/legend-graph 4.0.2 → 6.0.0

package/src/models/protocols/pure/v1/model/test/V1_Test.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 V1_Test implements Hashable {
+  id!: string;
+
+  abstract get hashCode(): string;
+}

package/src/models/protocols/pure/v1/model/test/V1_TestSuite.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 type { Hashable } from '@finos/legend-shared';
+import type { V1_AtomicTest } from './V1_AtomicTest';
+import { V1_Test } from './V1_Test';
+
+export abstract class V1_TestSuite extends V1_Test implements Hashable {
+  tests: V1_AtomicTest[] = [];
+
+  abstract override get hashCode(): string;
+}

package/src/models/protocols/pure/v1/model/test/assertion/V1_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 { V1_TestAssertion } from './V1_TestAssertion';
+
+export class V1_EqualTo extends V1_TestAssertion implements Hashable {
+  expected!: object;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EQUAL_TO,
+      this.id,
+      hashObjectWithoutSourceInformation(this.expected),
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/assertion/V1_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 { V1_ExternalFormatData } from '../../data/V1_EmbeddedData';
+import { V1_TestAssertion } from './V1_TestAssertion';
+
+export class V1_EqualToJson extends V1_TestAssertion implements Hashable {
+  expected!: V1_ExternalFormatData;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EQUAL_TO_JSON,
+      this.id,
+      this.expected,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/assertion/V1_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 V1_TestAssertionVisitor<T> {
+  visit_TestAssertion(testAssertion: V1_TestAssertion): T;
+}
+
+export abstract class V1_TestAssertion implements Hashable {
+  id!: string;
+
+  abstract get hashCode(): string;
+
+  accept_TestAssertionVisitor<T>(visitor: V1_TestAssertionVisitor<T>): T {
+    return visitor.visit_TestAssertion(this);
+  }
+}

package/src/models/protocols/pure/v1/model/test/assertion/status/V1_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 { V1_AssertionStatus } from './V1_AssertionStatus';
+
+export class V1_AssertFail extends V1_AssertionStatus implements Hashable {
+  message!: string;
+
+  get hashCode(): string {
+    return hashArray([CORE_HASH_STRUCTURE.ASSERT_FAIL, this.id, this.message]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/assertion/status/V1_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 { V1_AssertionStatus } from './V1_AssertionStatus';
+
+export class V1_AssertPass extends V1_AssertionStatus implements Hashable {
+  get hashCode(): string {
+    return hashArray([CORE_HASH_STRUCTURE.ASSERT_PASS, this.id]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/assertion/status/V1_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 V1_AssertionStatus implements Hashable {
+  id!: string;
+
+  abstract get hashCode(): string;
+}

package/src/models/protocols/pure/v1/model/test/assertion/status/V1_EqualToJsonAssertFail.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 { V1_AssertFail } from './V1_AssertFail';
+
+export class V1_EqualToJsonAssertFail
+  extends V1_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,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/result/V1_TestError.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 { V1_TestResult } from './V1_TestResult';
+
+export class V1_TestError extends V1_TestResult implements Hashable {
+  error!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TEST_ERROR,
+      this.testable,
+      this.atomicTestId,
+      this.error,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/result/V1_TestFailed.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 type { V1_AssertionStatus } from '../assertion/status/V1_AssertionStatus';
+import { V1_TestResult } from './V1_TestResult';
+
+export class V1_TestFailed extends V1_TestResult implements Hashable {
+  assertStatuses: V1_AssertionStatus[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TEST_FAILED,
+      this.testable,
+      this.atomicTestId,
+      hashArray(this.assertStatuses),
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/result/V1_TestPassed.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { V1_TestResult } from './V1_TestResult';
+
+export class V1_TestPassed extends V1_TestResult implements Hashable {
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TEST_PASSED,
+      this.testable,
+      this.atomicTestId,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/test/result/V1_TestResult.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 { V1_AtomicTestId } from '../V1_AtomicTestId';
+
+export class V1_TestResult implements Hashable {
+  testable!: string;
+  atomicTestId!: V1_AtomicTestId;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.ASSERT_FAIL,
+      this.testable,
+      this.atomicTestId,
+    ]);
+  }
+}

package/src/models/protocols/pure/v1/model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication.ts

@@ -19,7 +19,7 @@ import {
   type V1_ValueSpecificationVisitor,
 } from './V1_ValueSpecification';
 
-export class V1_INTERNAL__UnknownValueSpecfication extends V1_ValueSpecification {
+export class V1_INTERNAL__UnknownValueSpecification extends V1_ValueSpecification {
   content!: object;
 
   accept_ValueSpecificationVisitor<T>(

package/src/models/protocols/pure/v1/model/valueSpecification/V1_ValueSpecification.ts

@@ -50,7 +50,7 @@ import type { V1_AppliedProperty } from './application/V1_AppliedProperty';
 import type { V1_PackageableElementPtr } from './raw/V1_PackageableElementPtr';
 import type { V1_HackedClass } from './raw/V1_HackedClass';
 import type { V1_HackedUnit } from './raw/V1_HackedUnit';
-import type { V1_INTERNAL__UnknownValueSpecfication } from './V1_INTERNAL__UnknownValueSpecfication';
+import type { V1_INTERNAL__UnknownValueSpecification } from './V1_INTERNAL__UnknownValueSpecfication';
 
 export interface V1_ValueSpecificationVisitor<T> {
   visit_PackageableElementPtr(valueSpecification: V1_PackageableElementPtr): T;
@@ -99,7 +99,7 @@ export interface V1_ValueSpecificationVisitor<T> {
   visit_TdsOlapAggregation(valueSpecification: V1_TdsOlapAggregation): T;
 
   visit_INTERNAL__UnknownValueSpecfication(
-    valueSpecification: V1_INTERNAL__UnknownValueSpecfication,
+    valueSpecification: V1_INTERNAL__UnknownValueSpecification,
   ): T;
 }
 

package/src/models/protocols/pure/v1/model/valueSpecification/raw/path/V1_PathElement.ts

@@ -14,6 +14,4 @@
  * limitations under the License.
  */
 
-export abstract class V1_PathElement {
-  private readonly _$nominalTypeBrand!: 'V1_PathElement';
-}
+export abstract class V1_PathElement {}

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_ConnectionTransformer.ts

@@ -280,6 +280,7 @@ export const V1_transformRelationalDatabaseConnection = (
     context,
   );
   connection.type = metamodel.type as unknown as V1_DatabaseType;
+  connection.databaseType = connection.type;
   connection.timeZone = metamodel.timeZone;
   connection.quoteIdentifiers = metamodel.quoteIdentifiers;
   if (metamodel.postProcessors.length) {

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_DataElementTransformer.ts

@@ -0,0 +1,112 @@
+/**
+ * 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 { UnsupportedOperationError } from '@finos/legend-shared';
+import {
+  type EmbeddedData,
+  DataElementReference,
+  ExternalFormatData,
+  ModelStoreData,
+} from '../../../../../../metamodels/pure/data/EmbeddedData';
+import type { DataElement } from '../../../../../../metamodels/pure/packageableElements/data/DataElement';
+import type { DSLData_PureProtocolProcessorPlugin_Extension } from '../../../../DSLData_PureProtocolProcessorPlugin_Extension';
+import {
+  type V1_EmbeddedData,
+  V1_DataElementReference,
+  V1_ExternalFormatData,
+  V1_ModelStoreData,
+} from '../../../model/data/V1_EmbeddedData';
+import { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement';
+import { V1_initPackageableElement } from './V1_CoreTransformerHelper';
+import {
+  V1_transformStereotype,
+  V1_transformTaggedValue,
+} from './V1_DomainTransformer';
+import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext';
+
+// ----------------------------------------------- DATA ----------------------------------------
+
+export const V1_transformModelStoreData = (
+  element: ModelStoreData,
+): V1_ModelStoreData => {
+  const modelStoreDataElement = new V1_ModelStoreData();
+  const v1Instances = new Map<string, object>();
+  Array.from(element.instances.entries()).forEach((e) =>
+    v1Instances.set(e[0].path, e[1]),
+  );
+  modelStoreDataElement.instances = v1Instances;
+  return modelStoreDataElement;
+};
+
+export const V1_transformExternalFormatData = (
+  element: ExternalFormatData,
+): V1_ExternalFormatData => {
+  const externalFormatDataElement = new V1_ExternalFormatData();
+  externalFormatDataElement.contentType = element.contentType;
+  externalFormatDataElement.data = element.data;
+  return externalFormatDataElement;
+};
+
+export const V1_transformDataElementReference = (
+  element: DataElementReference,
+): V1_DataElementReference => {
+  const dataElementReference = new V1_DataElementReference();
+  dataElementReference.dataElement =
+    element.dataElement.valueForSerialization ?? '';
+  return dataElementReference;
+};
+
+export const V1_transformEmbeddedData = (
+  metamodel: EmbeddedData,
+  context: V1_GraphTransformerContext,
+): V1_EmbeddedData => {
+  if (metamodel instanceof ModelStoreData) {
+    return V1_transformModelStoreData(metamodel);
+  } else if (metamodel instanceof ExternalFormatData) {
+    return V1_transformExternalFormatData(metamodel);
+  } else if (metamodel instanceof DataElementReference) {
+    return V1_transformDataElementReference(metamodel);
+  }
+  const extraEmbeddedDataTransformers = context.plugins.flatMap(
+    (plugin) =>
+      (
+        plugin as DSLData_PureProtocolProcessorPlugin_Extension
+      ).V1_getExtraEmbeddedDataTransformers?.() ?? [],
+  );
+  for (const transformer of extraEmbeddedDataTransformers) {
+    const protocol = transformer(metamodel, context);
+    if (protocol) {
+      return protocol;
+    }
+  }
+
+  throw new UnsupportedOperationError(
+    `Can't transform embedded data: no compatible transformer available from plugins`,
+    metamodel,
+  );
+};
+
+export const V1_transformDataElement = (
+  element: DataElement,
+  context: V1_GraphTransformerContext,
+): V1_DataElement => {
+  const dataElement = new V1_DataElement();
+  V1_initPackageableElement(dataElement, element);
+  dataElement.stereotypes = element.stereotypes.map(V1_transformStereotype);
+  dataElement.taggedValues = element.taggedValues.map(V1_transformTaggedValue);
+  dataElement.data = V1_transformEmbeddedData(element.data, context);
+  return dataElement;
+};