@finos/legend-graph 31.0.4 → 31.1.1

package/src/graph-manager/GraphManagerState.ts

@@ -159,7 +159,11 @@ export class GraphManagerState extends BasicGraphManagerState {
       this.pluginManager.getPureGraphPlugins(),
     );
   }
-
+  /**
+   * NOTE: for all elements the ordering of usable elements will be own elements, system elements, dependency elements.
+   * Exception is made for types and profiles where we will show primitive and system elements first as those will be
+   * leveraged most by users
+   */
   get usableClassPropertyTypes(): Type[] {
     return [
       ...this.graph.primitiveTypes.filter(
@@ -179,147 +183,147 @@ export class GraphManagerState extends BasicGraphManagerState {
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownProfiles,
       ),
-      ...this.graph.dependencyManager.profiles,
       ...this.graph.ownProfiles,
+      ...this.graph.dependencyManager.profiles,
     ];
   }
   get usableEnumerations(): Enumeration[] {
     return [
+      ...this.graph.ownEnumerations,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownEnumerations,
       ),
       ...this.graph.dependencyManager.enumerations,
-      ...this.graph.ownEnumerations,
     ];
   }
   get usableMeasures(): Measure[] {
     return [
+      ...this.graph.ownMeasures,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownMeasures,
       ),
       ...this.graph.dependencyManager.measures,
-      ...this.graph.ownMeasures,
     ];
   }
   get usableClasses(): Class[] {
     return [
+      ...this.graph.ownClasses,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownClasses,
       ),
       ...this.graph.dependencyManager.classes,
-      ...this.graph.ownClasses,
     ];
   }
   get usableAssociationPropertyClasses(): Class[] {
-    return [...this.graph.dependencyManager.classes, ...this.graph.ownClasses];
+    return [...this.graph.ownClasses, ...this.graph.dependencyManager.classes];
   }
 
   get usableAssociations(): Association[] {
     return [
+      ...this.graph.ownAssociations,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownAssociations,
       ),
       ...this.graph.dependencyManager.associations,
-      ...this.graph.ownAssociations,
     ];
   }
   get usableFunctions(): ConcreteFunctionDefinition[] {
     return [
+      ...this.graph.ownFunctions,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownFunctions,
       ),
       ...this.graph.dependencyManager.functions,
-      ...this.graph.ownFunctions,
     ];
   }
   get usableStores(): Store[] {
     return [
+      ...this.graph.ownStores,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownStores,
       ),
       ...this.graph.dependencyManager.stores,
-      ...this.graph.ownStores,
     ];
   }
   get usableDatabases(): Database[] {
     return [
+      ...this.graph.ownDatabases,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownDatabases,
       ),
       ...this.graph.dependencyManager.databases,
-      ...this.graph.ownDatabases,
     ];
   }
   get usableMappings(): Mapping[] {
     return [
+      ...this.graph.ownMappings,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownMappings,
       ),
       ...this.graph.dependencyManager.mappings,
-      ...this.graph.ownMappings,
     ];
   }
   get usableServices(): Service[] {
     return [
+      ...this.graph.ownServices,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownServices,
       ),
       ...this.graph.dependencyManager.services,
-      ...this.graph.ownServices,
     ];
   }
   get usableRuntimes(): PackageableRuntime[] {
     return [
+      ...this.graph.ownRuntimes,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownRuntimes,
       ),
       ...this.graph.dependencyManager.runtimes,
-      ...this.graph.ownRuntimes,
     ];
   }
   get usableConnections(): PackageableConnection[] {
     return [
+      ...this.graph.ownConnections,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownConnections,
       ),
       ...this.graph.dependencyManager.connections,
-      ...this.graph.ownConnections,
     ];
   }
   get usableDataElements(): DataElement[] {
     return [
+      ...this.graph.ownDataElements,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownDataElements,
       ),
       ...this.graph.dependencyManager.dataElements,
-      ...this.graph.ownDataElements,
     ];
   }
   get usableGenerationSpecifications(): GenerationSpecification[] {
     return [
+      ...this.graph.ownGenerationSpecifications,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownGenerationSpecifications,
       ),
       ...this.graph.dependencyManager.generationSpecifications,
-      ...this.graph.ownGenerationSpecifications,
     ];
   }
   get usableFileGenerations(): FileGenerationSpecification[] {
     return [
+      ...this.graph.ownFileGenerations,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.ownFileGenerations,
       ),
       ...this.graph.dependencyManager.fileGenerations,
-      ...this.graph.ownFileGenerations,
     ];
   }
   get usableElements(): PackageableElement[] {
     return [
+      ...this.graph.ownMeasures,
       ...this.graphManager.collectExposedSystemElements(
         this.graph.systemModel.allOwnElements,
       ),
       ...this.graph.dependencyManager.allOwnElements,
-      ...this.graph.ownMeasures,
     ];
   }
 }

package/src/graph-manager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -291,6 +291,7 @@ import { FunctionActivatorConfiguration } from '../../../action/functionActivato
 import { V1_FunctionActivatorInput } from './engine/functionActivator/V1_FunctionActivatorInput.js';
 import { V1_FunctionActivator } from './model/packageableElements/function/V1_FunctionActivator.js';
 import { V1_INTERNAL__UnknownFunctionActivator } from './model/packageableElements/function/V1_INTERNAL__UnknownFunctionActivator.js';
+import { V1_DatabaseToModelGenerationInput } from './engine/relational/V1_DatabaseToModelGenerationInput.js';
 import type { RelationalDatabaseConnection } from '../../../../STO_Relational_Exports.js';
 import { V1_RawSQLExecuteInput } from './engine/execution/V1_RawSQLExecuteInput.js';
 import type { SubtypeInfo } from '../../../action/protocol/ProtocolInfo.js';
@@ -2996,6 +2997,21 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     await this.engine.publishFunctionActivatorToSandbox(input);
   }
 
+  // --------------------------------------------- Relational ---------------------------------------------
+
+  async generateModelsFromDatabaseSpecification(
+    databasePath: string,
+    graph: PureModel,
+  ): Promise<Entity[]> {
+    const graphData = this.graphToPureModelContextData(graph);
+    const input = new V1_DatabaseToModelGenerationInput();
+    input.databasePath = databasePath;
+    input.modelData = graphData;
+    const generatedModel =
+      await this.engine.generateModelsFromDatabaseSpecification(input);
+    return this.pureModelContextDataToEntities(generatedModel);
+  }
+
   // --------------------------------------------- Service ---------------------------------------------
 
   async registerService(

package/src/graph-manager/protocol/pure/v1/engine/V1_Engine.ts

@@ -135,6 +135,7 @@ import {
   V1_ArtifactGenerationExtensionOutput,
   V1_ArtifactGenerationExtensionInput,
 } from './generation/V1_ArtifactGenerationExtensionApi.js';
+import { V1_DatabaseToModelGenerationInput } from './relational/V1_DatabaseToModelGenerationInput.js';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -1013,4 +1014,31 @@ export class V1_Engine {
       );
     }
   }
+
+  // ------------------------------------------- Relational -------------------------------------------
+
+  async generateModelsFromDatabaseSpecification(
+    input: V1_DatabaseToModelGenerationInput,
+  ): Promise<V1_PureModelContextData> {
+    try {
+      const json =
+        await this.engineServerClient.generateModelsFromDatabaseSpecification(
+          V1_DatabaseToModelGenerationInput.serialization.toJson(input),
+        );
+      return V1_deserializePureModelContextData(json);
+    } catch (error) {
+      assertErrorThrown(error);
+      if (
+        error instanceof NetworkClientError &&
+        error.response.status === HttpStatus.BAD_REQUEST
+      ) {
+        throw V1_buildParserError(
+          V1_ParserError.serialization.fromJson(
+            error.payload as PlainObject<V1_ParserError>,
+          ),
+        );
+      }
+      throw error;
+    }
+  }
 }

package/src/graph-manager/protocol/pure/v1/engine/V1_EngineServerClient.ts

@@ -77,11 +77,14 @@ import type {
   V1_ArtifactGenerationExtensionInput,
   V1_ArtifactGenerationExtensionOutput,
 } from './generation/V1_ArtifactGenerationExtensionApi.js';
+import type { V1_DatabaseToModelGenerationInput } from './relational/V1_DatabaseToModelGenerationInput.js';
 
 enum CORE_ENGINE_ACTIVITY_TRACE {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
   JSON_TO_GRAMMAR = 'transform protocol to Pure code',
 
+  DATABASE_TO_MODELS = 'generate models from database',
+
   EXTERNAL_FORMAT_TO_PROTOCOL = 'transform external format code to protocol',
   GENERATE_FILE = 'generate file',
 
@@ -774,6 +777,20 @@ export class V1_EngineServerClient extends AbstractServerClient {
     );
   }
 
+  // ------------------------------------------- Relational ---------------------------------------
+
+  _relationalElement = (): string => `${this._pure()}/relational`;
+
+  generateModelsFromDatabaseSpecification(
+    input: PlainObject<V1_DatabaseToModelGenerationInput>,
+  ): Promise<PlainObject<V1_PureModelContextData>> {
+    return this.postWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.DATABASE_TO_MODELS),
+      `${this._relationalElement()}/generateModelsFromDatabaseSpecification`,
+      this.debugPayload(input, CORE_ENGINE_ACTIVITY_TRACE.DATABASE_TO_MODELS),
+    );
+  }
+
   // ------------------------------------------- Service -------------------------------------------
 
   _service = (serviceServerUrl?: string): string =>

package/src/graph-manager/protocol/pure/v1/engine/relational/V1_DatabaseToModelGenerationInput.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 { primitive, createModelSchema } from 'serializr';
+import { SerializationFactory } from '@finos/legend-shared';
+import type { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData.js';
+import { V1_pureModelContextDataPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization.js';
+
+export class V1_DatabaseToModelGenerationInput {
+  databasePath!: string;
+  modelData!: V1_PureModelContextData;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DatabaseToModelGenerationInput, {
+      databasePath: primitive(),
+      modelData: V1_pureModelContextDataPropSchema,
+    }),
+  );
+}

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementBuilder.ts

@@ -17,20 +17,29 @@
 import {
   type GenericClazz,
   assertNonEmptyString,
-  assertTrue,
   AssertionError,
+  guaranteeNonNullable,
 } from '@finos/legend-shared';
+import type { BasicModel } from '../../../../../../../graph/BasicModel.js';
+import { DependencyModel } from '../../../../../../../graph/DependencyManager.js';
+import { LegendSDLC } from '../../../../../../../graph/GraphDataOrigin.js';
 import {
   addElementToPackage,
+  getElementOrigin,
   getOrCreateGraphPackage,
 } from '../../../../../../../graph/helpers/DomainHelper.js';
 import type { Package } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Package.js';
 import type { PackageableElement } from '../../../../../../../graph/metamodel/pure/packageableElements/PackageableElement.js';
+import {
+  GenerationModel,
+  SystemModel,
+} from '../../../../../../../graph/PureModel.js';
 import type { V1_PackageableElement } from '../../../model/packageableElements/V1_PackageableElement.js';
 import {
   V1_buildFullPath,
   type V1_GraphBuilderContext,
 } from './V1_GraphBuilderContext.js';
+import { GAV_DELIMITER } from '@finos/legend-storage';
 
 export type V1_ElementBuilderPass = (
   elementProtocol: V1_PackageableElement,
@@ -46,6 +55,20 @@ export type V1_ElementThirdPassBuilder = V1_ElementBuilderPass;
 export type V1_ElementFourthPassBuilder = V1_ElementBuilderPass;
 export type V1_ElementFifthPassBuilder = V1_ElementBuilderPass;
 
+const currentSubGraphOrigin = (graph: BasicModel): string => {
+  if (graph instanceof SystemModel) {
+    return 'System elements';
+  } else if (graph instanceof GenerationModel) {
+    return 'Generation elements';
+  } else if (
+    graph instanceof DependencyModel &&
+    graph.origin instanceof LegendSDLC
+  ) {
+    return `Project dependency ${graph.origin.groupId}${GAV_DELIMITER}${graph.origin.artifactId} `;
+  }
+  return '';
+};
+
 export const V1_checkDuplicatedElement = (
   path: string,
   context: V1_GraphBuilderContext,
@@ -53,15 +76,29 @@ export const V1_checkDuplicatedElement = (
 ): void => {
   if (cache) {
     if (cache.has(path)) {
-      throw new AssertionError(`Element '${path}' already exists`);
+      const element = context.graph.getNullableElement(path);
+      const _origin = getElementOrigin(
+        guaranteeNonNullable(element),
+        context.graph,
+      );
+      throw new AssertionError(
+        `${currentSubGraphOrigin(
+          context.currentSubGraph,
+        )}Element '${path}' already exists${_origin ? ` in ${_origin}` : ''}`,
+      );
     } else {
       cache.add(path);
     }
   } else {
-    assertTrue(
-      !context.graph.getNullableElement(path),
-      `Element '${path}' already exists`,
-    );
+    const element = context.graph.getNullableElement(path);
+    if (element) {
+      const _origin = getElementOrigin(element, context.graph);
+      throw new AssertionError(
+        `${currentSubGraphOrigin(
+          context.currentSubGraph,
+        )}Element '${path}' already exists${_origin ? ` in ${_origin}` : ''}`,
+      );
+    }
   }
 };
 

package/tsconfig.json

@@ -388,6 +388,7 @@
     "./src/graph-manager/protocol/pure/v1/engine/import/V1_PureModelContextGenerationInput.ts",
     "./src/graph-manager/protocol/pure/v1/engine/query/V1_Query.ts",
     "./src/graph-manager/protocol/pure/v1/engine/query/V1_QuerySearchSpecification.ts",
+    "./src/graph-manager/protocol/pure/v1/engine/relational/V1_DatabaseToModelGenerationInput.ts",
     "./src/graph-manager/protocol/pure/v1/engine/service/V1_DEPRECATED__ServiceTestResult.ts",
     "./src/graph-manager/protocol/pure/v1/engine/service/V1_ServiceConfiguration.ts",
     "./src/graph-manager/protocol/pure/v1/engine/service/V1_ServiceRegistrationResult.ts",