@finos/legend-query-builder 0.0.1 → 0.1.0

package/src/stores/ServiceInfo.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 {
+  MASTER_SNAPSHOT_ALIAS,
+  SNAPSHOT_VERSION_ALIAS,
+  type StoredEntity,
+} from '@finos/legend-server-depot';
+import { isString } from '@finos/legend-shared';
+import { type Entity, extractEntityNameFromPath } from '@finos/legend-storage';
+
+export interface ServiceInfo {
+  groupId: string;
+  artifactId: string;
+  versionId: string;
+  path: string;
+  name: string;
+  entity: Entity;
+  urlPattern?: string | undefined;
+}
+
+export const extractServiceInfo = (
+  storedEntity: StoredEntity,
+): ServiceInfo => ({
+  groupId: storedEntity.groupId,
+  artifactId: storedEntity.artifactId,
+  versionId:
+    storedEntity.versionId === MASTER_SNAPSHOT_ALIAS
+      ? SNAPSHOT_VERSION_ALIAS
+      : storedEntity.versionId,
+  path: storedEntity.entity.path,
+  name: extractEntityNameFromPath(storedEntity.entity.path),
+  entity: storedEntity.entity,
+  // NOTE: we don't want to assert the existence of this field even when it
+  // is required in the specification of service to avoid throwing error here
+  urlPattern: isString(storedEntity.entity.content.pattern)
+    ? storedEntity.entity.content.pattern
+    : undefined,
+});

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -26,7 +26,6 @@ import {
 } from '@finos/legend-shared';
 import {
   type AbstractProperty,
-  type PureModel,
   type Type,
   type MappingModelCoverageAnalysisResult,
   type EnumMappedProperty,
@@ -60,14 +59,7 @@ import {
   getAllSubclasses,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
-import {
-  action,
-  flow,
-  flowResult,
-  makeAutoObservable,
-  makeObservable,
-  observable,
-} from 'mobx';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../QueryBuilderConfig.js';
 import {
   buildNonNumericPreviewDataQuery,
@@ -198,14 +190,17 @@ export class QueryBuilderExplorerTreeSubTypeNodeData extends QueryBuilderExplore
 }
 
 export const buildPropertyExpressionFromExplorerTreeNodeData = (
-  treeData: TreeData<QueryBuilderExplorerTreeNodeData>,
   node: QueryBuilderExplorerTreePropertyNodeData,
-  graph: PureModel,
-  allMappedPropertyNodes: QueryBuilderExplorerTreeNodeData[],
+  explorerState: QueryBuilderExplorerState,
 ): AbstractPropertyExpression => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
+  const treeData = explorerState.nonNullableTreeData;
+  const propertySearchIndexedTreeNodes =
+    explorerState.propertySearchState.indexedExplorerTreeNodes;
+
+  const multiplicityOne =
+    explorerState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
   const projectionColumnLambdaVariable = new VariableExpression(
     DEFAULT_LAMBDA_VARIABLE_NAME,
     multiplicityOne,
@@ -219,13 +214,13 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
     propertyExpression;
   let parentNode =
     treeData.nodes.get(node.parentId) ??
-    allMappedPropertyNodes.find((n) => n.id === node.parentId);
+    propertySearchIndexedTreeNodes.find((n) => n.id === node.parentId);
   let currentNode: QueryBuilderExplorerTreeNodeData = node;
   while (
     parentNode instanceof QueryBuilderExplorerTreePropertyNodeData ||
     parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
   ) {
-    // NOTE: here, we deliverately simplify subtypes chain
+    // NOTE: here, we deliberately simplify subtypes chain
     // $x.employees->subType(@Person)->subType(@Staff).department will be simplified to $x.employees->subType(@Staff).department
     if (
       parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData &&
@@ -270,7 +265,7 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
       (currentNode instanceof QueryBuilderExplorerTreePropertyNodeData ||
         currentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData)
     ) {
-      for (const propertyNode of allMappedPropertyNodes) {
+      for (const propertyNode of propertySearchIndexedTreeNodes) {
         if (propertyNode.id === currentNode.parentId) {
           parentNode = propertyNode;
           break;
@@ -566,8 +561,10 @@ export class QueryBuilderExplorerPreviewDataState {
   previewData?: QueryBuilderPreviewData | undefined;
 
   constructor() {
-    makeAutoObservable(this, {
+    makeObservable(this, {
       previewData: observable.ref,
+      isGeneratingPreviewData: observable,
+      propertyName: observable,
       setPropertyName: action,
       setIsGeneratingPreviewData: action,
       setPreviewData: action,
@@ -588,30 +585,31 @@ export class QueryBuilderExplorerPreviewDataState {
 }
 
 export class QueryBuilderExplorerState {
-  queryBuilderState: QueryBuilderState;
-  previewDataState = new QueryBuilderExplorerPreviewDataState();
+  readonly queryBuilderState: QueryBuilderState;
+  readonly previewDataState = new QueryBuilderExplorerPreviewDataState();
+  readonly propertySearchState: QueryBuilderPropertySearchState;
   treeData?: TreeData<QueryBuilderExplorerTreeNodeData> | undefined;
   humanizePropertyName = true;
   showUnmappedProperties = false;
   highlightUsedProperties = true;
-  propertySearchState: QueryBuilderPropertySearchState;
-  mappingModelCoverageAnalysisResult?: MappingModelCoverageAnalysisResult;
   mappingModelCoverageAnalysisState = ActionState.create();
+  mappingModelCoverageAnalysisResult?: MappingModelCoverageAnalysisResult;
 
   constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      previewDataState: false,
+    makeObservable(this, {
       treeData: observable.ref,
+      humanizePropertyName: observable,
+      showUnmappedProperties: observable,
       highlightUsedProperties: observable,
+      mappingModelCoverageAnalysisResult: observable,
       setTreeData: action,
       refreshTree: action,
       refreshTreeData: action,
       setHumanizePropertyName: action,
       setShowUnmappedProperties: action,
-      previewData: flow,
       setHighlightUsedProperties: action,
       analyzeMappingModelCoverage: flow,
+      previewData: flow,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -711,10 +709,8 @@ export class QueryBuilderExplorerState {
     this.previewDataState.setPropertyName(node.property.name);
     this.previewDataState.setIsGeneratingPreviewData(true);
     const propertyExpression = buildPropertyExpressionFromExplorerTreeNodeData(
-      this.nonNullableTreeData,
       node,
-      this.queryBuilderState.graphManagerState.graph,
-      this.propertySearchState.allMappedPropertyNodes,
+      this,
     );
     const propertyType = node.property.genericType.value.rawType;
     try {