@finos/legend-graph 11.0.0 → 12.0.0

package/src/graph/MetaModelUtils.ts

@@ -0,0 +1,110 @@
+/**
+ * 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.
+ */
+
+/**
+ * NOTE: this file holds the most basic utilties to deal with the graph and
+ * metamodels. Any methods which requires importing some metamodel or graph
+ * are meant to be put into helpers method, e.g. `DomainHelper`.
+ *
+ * This is to avoid circular dependencies and also to keep things in the
+ * right layer
+ */
+
+import {
+  ELEMENT_PATH_DELIMITER,
+  SOURCE_INFORMATION_PROPERTY_KEY_SUFFIX,
+} from './MetaModelConst.js';
+import {
+  findLast,
+  guaranteeNonNullable,
+  isString,
+  recursiveOmit,
+} from '@finos/legend-shared';
+
+export const extractElementNameFromPath = (fullPath: string): string =>
+  guaranteeNonNullable(findLast(fullPath.split(ELEMENT_PATH_DELIMITER)));
+
+export const matchFunctionName = (
+  functionName: string,
+  functionFullPath: string,
+): boolean =>
+  functionName === functionFullPath ||
+  extractElementNameFromPath(functionFullPath) === functionName;
+
+/**
+ * This method concatenate 2 fully-qualified elementh paths to form a single one
+ * and then extracts the name and package part from it.
+ */
+export const resolvePackagePathAndElementName = (
+  path: string,
+  defaultPath?: string,
+): [string, string] => {
+  const index = path.lastIndexOf(ELEMENT_PATH_DELIMITER);
+  if (index === -1) {
+    return [defaultPath ?? '', path];
+  }
+  return [
+    path.substring(0, index),
+    path.substring(index + ELEMENT_PATH_DELIMITER.length, path.length),
+  ];
+};
+
+export const buildPath = (
+  packagePath: string | undefined,
+  name: string | undefined,
+): string =>
+  `${guaranteeNonNullable(
+    packagePath,
+    'Package path is required',
+  )}${ELEMENT_PATH_DELIMITER}${guaranteeNonNullable(name, 'Name is required')}`;
+export const createPath = (packagePath: string, name: string): string =>
+  `${packagePath ? `${packagePath}${ELEMENT_PATH_DELIMITER}` : ''}${name}`;
+// TODO: we might need to support quoted identifier in the future
+export const isValidPathIdentifier = (val: string): boolean =>
+  Boolean(val.match(/^\w[\w$_-]*$/));
+export const isValidFullPath = (fullPath: string): boolean =>
+  Boolean(fullPath.match(/^(?:\w[\w$_-]*)(?:::\w[\w$_-]*)+$/));
+export const isValidPath = (path: string): boolean =>
+  Boolean(path.match(/^(?:\w[\w$_-]*)(?:::\w[\w$_-]*)*$/));
+
+export const fromElementPathToMappingElementId = (className: string): string =>
+  className.split(ELEMENT_PATH_DELIMITER).join('_');
+
+/**
+ * Prune source information from object such as raw lambda, raw value specification, etc.
+ *
+ * NOTE: currently, there is no exhaustive way to do this. Majority of the cases, the source information field
+ * is suffixed with `sourceInformation` (e.g. `profileSourceInformation`, `propertyTypeSourceInformation`),
+ * however, we have sometimes deviated from this pattern in our protocol model, so we have fields like `classSourceInformation`,
+ * etc. So this is really an optimistic, non-exhaustive prune.
+ *
+ * To do this exhaustively, we need to tweak this method to also check for the structure of the (sub)object to make sure
+ * it is structually equivalent to the shape of source information to prune it. However, this is computationally expensive.
+ *
+ * NOTE: That aside, We should cleanup these in the backend and use pointer instead so source information is coupled
+ * with the value instead of having custom-name source information fields like these, polluting the protocol models.
+ */
+export const pruneSourceInformation = (
+  object: Record<PropertyKey, unknown>,
+): Record<PropertyKey, unknown> =>
+  recursiveOmit(
+    object,
+    (obj, propKey) =>
+      isString(propKey) &&
+      propKey
+        .toLowerCase()
+        .endsWith(SOURCE_INFORMATION_PROPERTY_KEY_SUFFIX.toLowerCase()),
+  );

package/src/graph/PureGraphExtension.ts

@@ -15,7 +15,7 @@
  */
 
 import type { Clazz } from '@finos/legend-shared';
-import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement.js';
+import type { PackageableElement } from '../graph/metamodel/pure/packageableElements/PackageableElement.js';
 
 export class PureGraphExtension<T extends PackageableElement> {
   private readonly _class: Clazz<T>;

package/src/graph/PureGraphPlugin.ts

@@ -15,10 +15,10 @@
  */
 
 import { AbstractPlugin, type Clazz } from '@finos/legend-shared';
-import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement.js';
+import type { PackageableElement } from '../graph/metamodel/pure/packageableElements/PackageableElement.js';
 import type { PureModel } from './PureModel.js';
-import type { GraphPluginManager } from '../GraphPluginManager.js';
-import type { Testable } from '../models/metamodels/pure/test/Testable.js';
+import type { GraphPluginManager } from './GraphPluginManager.js';
+import type { Testable } from '../graph/metamodel/pure/test/Testable.js';
 
 export type DeadReferencesCleaner = (graph: PureModel) => void;
 export type TestablesCollector = (graph: PureModel) => Testable[];

package/src/graph/PureModel.ts

@@ -19,7 +19,7 @@ import {
   ROOT_PACKAGE_NAME,
   TYPICAL_MULTIPLICITY_TYPE,
   AUTO_IMPORTS,
-} from '../MetaModelConst.js';
+} from '../graph/MetaModelConst.js';
 import {
   type Clazz,
   guaranteeNonNullable,
@@ -27,37 +27,37 @@ import {
   returnUndefOnError,
   IllegalStateError,
 } from '@finos/legend-shared';
-import { PrimitiveType } from '../models/metamodels/pure/packageableElements/domain/PrimitiveType.js';
-import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration.js';
-import { Multiplicity } from '../models/metamodels/pure/packageableElements/domain/Multiplicity.js';
-import type { Association } from '../models/metamodels/pure/packageableElements/domain/Association.js';
-import { Package } from '../models/metamodels/pure/packageableElements/domain/Package.js';
-import type { Type } from '../models/metamodels/pure/packageableElements/domain/Type.js';
-import { Class } from '../models/metamodels/pure/packageableElements/domain/Class.js';
-import type { Mapping } from '../models/metamodels/pure/packageableElements/mapping/Mapping.js';
-import type { Profile } from '../models/metamodels/pure/packageableElements/domain/Profile.js';
-import type { Store } from '../models/metamodels/pure/packageableElements/store/Store.js';
+import { PrimitiveType } from '../graph/metamodel/pure/packageableElements/domain/PrimitiveType.js';
+import { Enumeration } from '../graph/metamodel/pure/packageableElements/domain/Enumeration.js';
+import { Multiplicity } from '../graph/metamodel/pure/packageableElements/domain/Multiplicity.js';
+import type { Association } from '../graph/metamodel/pure/packageableElements/domain/Association.js';
+import { Package } from '../graph/metamodel/pure/packageableElements/domain/Package.js';
+import type { Type } from '../graph/metamodel/pure/packageableElements/domain/Type.js';
+import { Class } from '../graph/metamodel/pure/packageableElements/domain/Class.js';
+import type { Mapping } from '../graph/metamodel/pure/packageableElements/mapping/Mapping.js';
+import type { Profile } from '../graph/metamodel/pure/packageableElements/domain/Profile.js';
+import type { Store } from '../graph/metamodel/pure/packageableElements/store/Store.js';
 import { DependencyManager } from '../graph/DependencyManager.js';
-import { ConcreteFunctionDefinition } from '../models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
-import type { Service } from '../models/metamodels/pure/packageableElements/service/Service.js';
+import { ConcreteFunctionDefinition } from '../graph/metamodel/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import type { Service } from '../graph/metamodel/pure/packageableElements/service/Service.js';
 import { BasicModel } from './BasicModel.js';
-import { FlatData } from '../models/metamodels/pure/packageableElements/store/flatData/model/FlatData.js';
-import { Database } from '../models/metamodels/pure/packageableElements/store/relational/model/Database.js';
-import type { PackageableConnection } from '../models/metamodels/pure/packageableElements/connection/PackageableConnection.js';
-import type { PackageableRuntime } from '../models/metamodels/pure/packageableElements/runtime/PackageableRuntime.js';
-import type { FileGenerationSpecification } from '../models/metamodels/pure/packageableElements/fileGeneration/FileGenerationSpecification.js';
-import { ModelStore } from '../models/metamodels/pure/packageableElements/store/modelToModel/model/ModelStore.js';
-import type { GenerationSpecification } from '../models/metamodels/pure/packageableElements/generationSpecification/GenerationSpecification.js';
+import { FlatData } from '../graph/metamodel/pure/packageableElements/store/flatData/model/FlatData.js';
+import { Database } from '../graph/metamodel/pure/packageableElements/store/relational/model/Database.js';
+import type { PackageableConnection } from '../graph/metamodel/pure/packageableElements/connection/PackageableConnection.js';
+import type { PackageableRuntime } from '../graph/metamodel/pure/packageableElements/runtime/PackageableRuntime.js';
+import type { FileGenerationSpecification } from '../graph/metamodel/pure/packageableElements/fileGeneration/FileGenerationSpecification.js';
+import { ModelStore } from '../graph/metamodel/pure/packageableElements/store/modelToModel/model/ModelStore.js';
+import type { GenerationSpecification } from '../graph/metamodel/pure/packageableElements/generationSpecification/GenerationSpecification.js';
 import {
   Measure,
   Unit,
-} from '../models/metamodels/pure/packageableElements/domain/Measure.js';
+} from '../graph/metamodel/pure/packageableElements/domain/Measure.js';
 import type { PureGraphPlugin } from './PureGraphPlugin.js';
-import { createPath } from '../MetaModelUtils.js';
-import type { DataElement } from '../models/metamodels/pure/packageableElements/data/DataElement.js';
-import type { Testable } from '../models/metamodels/pure/test/Testable.js';
-import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement.js';
-import type { SectionIndex } from '../models/metamodels/pure/packageableElements/section/SectionIndex.js';
+import { createPath } from '../graph/MetaModelUtils.js';
+import type { DataElement } from '../graph/metamodel/pure/packageableElements/data/DataElement.js';
+import type { Testable } from '../graph/metamodel/pure/test/Testable.js';
+import type { PackageableElement } from '../graph/metamodel/pure/packageableElements/PackageableElement.js';
+import type { SectionIndex } from '../graph/metamodel/pure/packageableElements/section/SectionIndex.js';
 
 /**
  * CoreModel holds meta models which are constant and basic building block of the graph. Since throughout the lifetime

package/src/graph/helpers/DSLGeneration_Helper.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { ConfigurationProperty } from '../metamodel/pure/packageableElements/fileGeneration/ConfigurationProperty.js';
+import type { FileGenerationSpecification } from '../metamodel/pure/packageableElements/fileGeneration/FileGenerationSpecification.js';
+
+export const getNullableFileGenerationConfig = (
+  fileGeneration: FileGenerationSpecification,
+  name: string,
+): ConfigurationProperty | undefined =>
+  fileGeneration.configurationProperties.find(
+    (property) => name === property.name,
+  );

package/src/graph/helpers/DSLMapping_Helper.ts

@@ -0,0 +1,300 @@
+/**
+ * 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 {
+  assertTrue,
+  filterByType,
+  findLast,
+  generateEnumerableNameFromToken,
+  guaranteeNonNullable,
+  uniq,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import type { EnumerationMapping } from '../metamodel/pure/packageableElements/mapping/EnumerationMapping.js';
+import type { SetImplementation } from '../metamodel/pure/packageableElements/mapping/SetImplementation.js';
+import type { Class } from '../metamodel/pure/packageableElements/domain/Class.js';
+import type { Enumeration } from '../metamodel/pure/packageableElements/domain/Enumeration.js';
+import type { Mapping } from '../metamodel/pure/packageableElements/mapping/Mapping.js';
+import { AggregationAwareSetImplementation } from '../metamodel/pure/packageableElements/mapping/aggregationAware/AggregationAwareSetImplementation.js';
+import { RootRelationalInstanceSetImplementation } from '../metamodel/pure/packageableElements/store/relational/mapping/RootRelationalInstanceSetImplementation.js';
+import type { PropertyMapping } from '../metamodel/pure/packageableElements/mapping/PropertyMapping.js';
+import type { InstanceSetImplementation } from '../metamodel/pure/packageableElements/mapping/InstanceSetImplementation.js';
+import type {
+  EngineRuntime,
+  IdentifiedConnection,
+} from '../metamodel/pure/packageableElements/runtime/Runtime.js';
+import { OperationSetImplementation } from '../metamodel/pure/packageableElements/mapping/OperationSetImplementation.js';
+import { ObjectInputType } from '../metamodel/pure/packageableElements/store/modelToModel/mapping/ObjectInputData.js';
+
+// ----------------------------------------- Mapping -----------------------------------------
+
+/**
+ * Get all included mappings, accounted for loop and duplication (which should be caught by compiler)
+ */
+export const getAllIncludedMappings = (mapping: Mapping): Mapping[] => {
+  const visited = new Set<Mapping>();
+  visited.add(mapping);
+  const resolveIncludes = (_mapping: Mapping): void => {
+    _mapping.includes.forEach((incMapping) => {
+      if (!visited.has(incMapping.included.value)) {
+        visited.add(incMapping.included.value);
+        resolveIncludes(incMapping.included.value);
+      }
+    });
+  };
+  resolveIncludes(mapping);
+  visited.delete(mapping);
+  return Array.from(visited);
+};
+
+export const getAllClassMappings = (mapping: Mapping): SetImplementation[] =>
+  uniq(
+    mapping.classMappings.concat(
+      getAllIncludedMappings(mapping)
+        .map((e) => e.classMappings)
+        .flat(),
+    ),
+  );
+
+export const getAllEnumerationMappings = (
+  mapping: Mapping,
+): EnumerationMapping[] =>
+  uniq(
+    mapping.enumerationMappings.concat(
+      getAllIncludedMappings(mapping)
+        .map((e) => e.enumerationMappings)
+        .flat(),
+    ),
+  );
+
+export const extractClassMappingsFromAggregationAwareClassMappings = (
+  mapping: Mapping,
+): SetImplementation[] => {
+  const aggregationAwareClassMappings = mapping.classMappings.filter(
+    filterByType(AggregationAwareSetImplementation),
+  );
+  return [
+    ...aggregationAwareClassMappings.map(
+      (aggregate) => aggregate.mainSetImplementation,
+    ),
+    ...aggregationAwareClassMappings
+      .map((aggregate) =>
+        aggregate.aggregateSetImplementations.map(
+          (setImpl) => setImpl.setImplementation,
+        ),
+      )
+      .flat(),
+  ];
+};
+
+export const getOwnClassMappingById = (
+  mapping: Mapping,
+  id: string,
+): SetImplementation =>
+  guaranteeNonNullable(
+    [
+      ...mapping.classMappings,
+      ...extractClassMappingsFromAggregationAwareClassMappings(mapping),
+    ].find((classMapping) => classMapping.id.value === id),
+    `Can't find class mapping with ID '${id}' in mapping '${mapping.path}'`,
+  );
+
+export const getClassMappingById = (
+  mapping: Mapping,
+  id: string,
+): SetImplementation =>
+  guaranteeNonNullable(
+    [
+      ...getAllClassMappings(mapping),
+      ...extractClassMappingsFromAggregationAwareClassMappings(mapping),
+    ].find((classMapping) => classMapping.id.value === id),
+    `Can't find class mapping with ID '${id}' in mapping '${mapping.path}'`,
+  );
+
+export const getOwnClassMappingsByClass = (
+  mapping: Mapping,
+  _class: Class,
+): SetImplementation[] =>
+  // TODO: Add association property Mapping to class mappings, AggregationAwareSetImplementation, mappingClass
+  // NOTE: Add in the proper order so find root can resolve properly down the line
+  mapping.classMappings.filter(
+    (classMapping) => classMapping.class.value === _class,
+  );
+
+export const getClassMappingsByClass = (
+  mapping: Mapping,
+  _class: Class,
+): SetImplementation[] =>
+  // TODO: Add association property Mapping to class mappings, AggregationAwareSetImplementation, mappingClass
+  // NOTE: Add in the proper order so find root can resolve properly down the line
+  getAllClassMappings(mapping).filter(
+    (classMapping) => classMapping.class.value === _class,
+  );
+
+export const getEnumerationMappingsByEnumeration = (
+  mapping: Mapping,
+  enumeration: Enumeration,
+): EnumerationMapping[] =>
+  getAllEnumerationMappings(mapping).filter(
+    (enumerationMapping) =>
+      enumerationMapping.enumeration.value === enumeration,
+  );
+
+export const getAllSuperSetImplementations = (
+  currentSetImpl: SetImplementation,
+): SetImplementation[] => {
+  if (
+    currentSetImpl instanceof RootRelationalInstanceSetImplementation &&
+    currentSetImpl.superSetImplementationId
+  ) {
+    const superSetImpl = [
+      getClassMappingById(
+        currentSetImpl._PARENT,
+        currentSetImpl.superSetImplementationId,
+      ),
+    ];
+    const superSetImplFromParents = superSetImpl
+      .map((s) => getAllSuperSetImplementations(s))
+      .flat();
+    return superSetImpl.concat(superSetImplFromParents);
+  } else {
+    return [];
+  }
+};
+
+export const findRootSetImplementation = (
+  classMappingsWithSimilarTarget: SetImplementation[],
+): SetImplementation | undefined => {
+  // NOTE: we use find last so that we can be sure we're picking the root set implementation of the current mapping first,
+  // not the root set implementation of one of the included mappings, in case there's no root, we would prefer the root
+  // of one of the included mappings (whichever comes later),
+  // if there is not root set, and only one set implementation is found, we assume that is the root
+  if (
+    classMappingsWithSimilarTarget.length === 1 &&
+    classMappingsWithSimilarTarget[0]?.root.value === false
+  ) {
+    return classMappingsWithSimilarTarget[0];
+  }
+  return findLast(
+    classMappingsWithSimilarTarget,
+    (setImp: SetImplementation) => setImp.root.value,
+  );
+};
+
+export const getRootSetImplementation = (
+  mapping: Mapping,
+  _class: Class,
+): SetImplementation | undefined =>
+  findRootSetImplementation(getClassMappingsByClass(mapping, _class));
+
+export const findPropertyMapping = (
+  instanceSetImplementation: InstanceSetImplementation,
+  propertyName: string,
+  targetId: string | undefined,
+): PropertyMapping | undefined => {
+  let properties = undefined;
+  properties = instanceSetImplementation.propertyMappings.filter(
+    (propertyMapping) => propertyMapping.property.value.name === propertyName,
+  );
+  if (targetId === undefined || properties.length === 1) {
+    return properties[0];
+  }
+  return properties.find(
+    (propertyMapping) =>
+      propertyMapping.targetSetImplementation &&
+      propertyMapping.targetSetImplementation.value.id.value === targetId,
+  );
+};
+
+/**
+ * Get all child set implementation of an operation set implementation (including itself).
+ * This takes into account loops and duplication.
+ */
+export const getAllChildSetImplementations = (
+  operationSetImplementation: OperationSetImplementation,
+): SetImplementation[] => {
+  const visitedOperations = new Set<OperationSetImplementation>();
+  visitedOperations.add(operationSetImplementation);
+  const _leaves = new Set<SetImplementation>();
+  const resolveLeaves = (_opSetImpl: OperationSetImplementation): void => {
+    _opSetImpl.parameters.forEach((p) => {
+      const setImp = p.setImplementation.value;
+      if (
+        setImp instanceof OperationSetImplementation &&
+        !visitedOperations.has(setImp)
+      ) {
+        visitedOperations.add(setImp);
+        resolveLeaves(setImp);
+      } else {
+        _leaves.add(setImp);
+      }
+    });
+  };
+  resolveLeaves(operationSetImplementation);
+  visitedOperations.delete(operationSetImplementation);
+  return Array.from(_leaves).concat(Array.from(visitedOperations));
+};
+
+/**
+ * Get all leaf set implementations (i.e. no operation) of an operation set implementation
+ * This takes into account loops and duplication.
+ */
+export const getLeafSetImplementations = (
+  operationSetImplementation: OperationSetImplementation,
+): SetImplementation[] =>
+  getAllChildSetImplementations(operationSetImplementation).filter(
+    (child) => !(child instanceof OperationSetImplementation),
+  );
+
+export const getObjectInputType = (type: string): ObjectInputType => {
+  switch (type) {
+    case ObjectInputType.JSON:
+      return ObjectInputType.JSON;
+    case ObjectInputType.XML:
+      return ObjectInputType.XML;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported object input type '${type}'`,
+      );
+  }
+};
+
+// ----------------------------------------- Runtime -----------------------------------------
+
+export const getAllIdentifiedConnections = (
+  runtime: EngineRuntime,
+): IdentifiedConnection[] =>
+  runtime.connections.flatMap(
+    (storeConnections) => storeConnections.storeConnections,
+  );
+
+export const generateIdentifiedConnectionId = (
+  runtime: EngineRuntime,
+): string => {
+  const generatedId = generateEnumerableNameFromToken(
+    getAllIdentifiedConnections(runtime).map(
+      (identifiedConnection) => identifiedConnection.id,
+    ),
+    'connection',
+  );
+  assertTrue(
+    !getAllIdentifiedConnections(runtime).find(
+      (identifiedConnection) => identifiedConnection.id === generatedId,
+    ),
+    `Can't auto-generate connection ID with value '${generatedId}'`,
+  );
+  return generatedId;
+};