@finos/legend-query-builder 0.0.1

package/src/components/workflows/ServiceQueryBuilder.tsx

@@ -0,0 +1,192 @@
+/**
+ * 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 {
+  CustomSelectorInput,
+  PURE_MappingIcon,
+  PURE_RuntimeIcon,
+  PlayIcon,
+} from '@finos/legend-art';
+import { observer } from 'mobx-react-lite';
+import { getMappingCompatibleClasses } from '@finos/legend-graph';
+import {
+  getPackageableElementOptionFormatter,
+  buildElementOption,
+  useApplicationStore,
+} from '@finos/legend-application';
+import {
+  buildRuntimeValueOption,
+  getRuntimeOptionFormatter,
+  QueryBuilderClassSelector,
+} from '../QueryBuilderSideBar.js';
+import type {
+  ServiceExecutionContext,
+  ServiceQueryBuilderState,
+} from '../../stores/workflows/ServiceQueryBuilderState.js';
+
+type ExecutionContextOption = {
+  label: string;
+  value: ServiceExecutionContext;
+};
+const buildExecutionContextOption = (
+  value: ServiceExecutionContext,
+): ExecutionContextOption => ({
+  label: value.key,
+  value,
+});
+
+/**
+ * This setup panel supports cascading in order: Execution Context -> Class
+ *
+ * In other words, we will only show:
+ * - For class selector: the list of compatible classes with the selected mapping
+ *
+ * See details on propagation/cascading in {@link ServiceQueryBuilderState}
+ */
+const ServiceQueryBuilderSetupPanelContent = observer(
+  (props: { queryBuilderState: ServiceQueryBuilderState }) => {
+    const { queryBuilderState } = props;
+    const applicationStore = useApplicationStore();
+
+    // mapping
+    const selectedMappingOption = queryBuilderState.mapping
+      ? buildElementOption(queryBuilderState.mapping)
+      : null;
+
+    // runtime
+    const selectedRuntimeOption = queryBuilderState.runtimeValue
+      ? buildRuntimeValueOption(queryBuilderState.runtimeValue)
+      : null;
+
+    // execution context
+    const executionContextOptions = queryBuilderState.executionContexts.map(
+      buildExecutionContextOption,
+    );
+    const selectedExecutionContextOption =
+      queryBuilderState.selectedExecutionContext
+        ? buildExecutionContextOption(
+            queryBuilderState.selectedExecutionContext,
+          )
+        : null;
+    const onExecutionContextOptionChange = (
+      option: ExecutionContextOption,
+    ): void => {
+      if (option.value === queryBuilderState.selectedExecutionContext) {
+        return;
+      }
+      queryBuilderState.setSelectedExecutionContext(option.value);
+      queryBuilderState.propagateExecutionContextChange(option.value);
+      queryBuilderState.onExecutionContextChange?.(option.value);
+    };
+
+    // class
+    const classes = queryBuilderState.mapping
+      ? getMappingCompatibleClasses(
+          queryBuilderState.mapping,
+          queryBuilderState.graphManagerState.usableClasses,
+        )
+      : [];
+
+    return (
+      <>
+        <div className="query-builder__setup__config-group">
+          <div className="query-builder__setup__config-group__header">
+            <div className="query-builder__setup__config-group__header__title">
+              service execution context
+            </div>
+          </div>
+          <div className="query-builder__setup__config-group__content">
+            {/* We will display mapping and runtime selector for single-execution and execution context for multi-execution */}
+            {Boolean(queryBuilderState.executionContexts.length) && (
+              <>
+                <div className="query-builder__setup__config-group__item">
+                  <div
+                    className="btn--sm query-builder__setup__config-group__item__label"
+                    title="execution context"
+                  >
+                    <PlayIcon className="query-builder__setup__service__icon__execution-context" />
+                  </div>
+                  <CustomSelectorInput
+                    className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
+                    placeholder="Choose an execution context..."
+                    options={executionContextOptions}
+                    disabled={executionContextOptions.length <= 1}
+                    onChange={onExecutionContextOptionChange}
+                    value={selectedExecutionContextOption}
+                    darkMode={!applicationStore.TEMPORARY__isLightThemeEnabled}
+                  />
+                </div>
+              </>
+            )}
+            {!queryBuilderState.executionContexts.length && (
+              <>
+                <div className="query-builder__setup__config-group__item">
+                  <div
+                    className="btn--sm query-builder__setup__config-group__item__label"
+                    title="mapping"
+                  >
+                    <PURE_MappingIcon />
+                  </div>
+                  <CustomSelectorInput
+                    className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
+                    disabled={true}
+                    options={[]}
+                    value={selectedMappingOption}
+                    darkMode={!applicationStore.TEMPORARY__isLightThemeEnabled}
+                    formatOptionLabel={getPackageableElementOptionFormatter({
+                      darkMode:
+                        !applicationStore.TEMPORARY__isLightThemeEnabled,
+                    })}
+                  />
+                </div>
+                <div className="query-builder__setup__config-group__item">
+                  <div
+                    className="btn--sm query-builder__setup__config-group__item__label"
+                    title="runtime"
+                  >
+                    <PURE_RuntimeIcon />
+                  </div>
+                  <CustomSelectorInput
+                    className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
+                    disabled={true}
+                    options={[]}
+                    value={selectedRuntimeOption}
+                    darkMode={!applicationStore.TEMPORARY__isLightThemeEnabled}
+                    formatOptionLabel={getRuntimeOptionFormatter({
+                      darkMode:
+                        !applicationStore.TEMPORARY__isLightThemeEnabled,
+                    })}
+                  />
+                </div>
+              </>
+            )}
+          </div>
+        </div>
+        <QueryBuilderClassSelector
+          queryBuilderState={queryBuilderState}
+          classes={classes}
+          noMatchMessage="No compatible class found for specified execution context"
+        />
+      </>
+    );
+  },
+);
+
+export const renderServiceQueryBuilderSetupPanelContent = (
+  queryBuilderState: ServiceQueryBuilderState,
+): React.ReactNode => (
+  <ServiceQueryBuilderSetupPanelContent queryBuilderState={queryBuilderState} />
+);

package/src/graphManager/QueryBuilderSupportedFunctions.ts

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+
+export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
+  AND = 'meta::pure::functions::boolean::and',
+  EXISTS = 'meta::pure::functions::collection::exists',
+  FILTER = 'meta::pure::functions::collection::filter',
+  GET_ALL = 'meta::pure::functions::collection::getAll',
+  NOT = 'meta::pure::functions::boolean::not',
+  OR = 'meta::pure::functions::boolean::or',
+  TAKE = 'meta::pure::functions::collection::take',
+  SUBTYPE = 'meta::pure::functions::lang::subType',
+
+  // graph-fetch
+  GRAPH_FETCH = 'meta::pure::graphFetch::execution::graphFetch',
+  GRAPH_FETCH_CHECKED = 'meta::pure::graphFetch::execution::graphFetchChecked',
+  SERIALIZE = 'meta::pure::graphFetch::execution::serialize',
+
+  // TDS
+  TDS_FILTER = 'meta::pure::tds::filter',
+  TDS_ASC = 'meta::pure::tds::asc',
+  TDS_DESC = 'meta::pure::tds::desc',
+  TDS_AGG = 'meta::pure::tds::agg',
+  TDS_DISTINCT = 'meta::pure::tds::distinct',
+  TDS_PROJECT = 'meta::pure::tds::project',
+  TDS_GROUP_BY = 'meta::pure::tds::groupBy',
+  TDS_SORT = 'meta::pure::tds::sort',
+  TDS_TAKE = 'meta::pure::tds::take',
+
+  // filter
+  CONTAINS = 'meta::pure::functions::string::contains',
+  ENDS_WITH = 'meta::pure::functions::string::endsWith',
+  EQUAL = 'meta::pure::functions::boolean::equal',
+  GREATER_THAN = 'meta::pure::functions::lang::tests::greaterThan',
+  GREATER_THAN_EQUAL = 'meta::pure::functions::lang::tests::greaterThanEqual',
+  IN = 'meta::pure::functions::collection::in',
+  IS_EMPTY = 'meta::pure::functions::collection::isEmpty',
+  LESS_THAN = 'meta::pure::functions::lang::tests::lessThan',
+  LESS_THAN_EQUAL = 'meta::pure::functions::lang::tests::lessThanEqual',
+  STARTS_WITH = 'meta::pure::functions::string::startsWith',
+  // aggregation
+  AVERAGE = 'meta::pure::functions::math::average',
+  COUNT = 'meta::pure::functions::collection::count',
+  JOIN_STRINGS = 'meta::pure::functions::string::joinStrings',
+  DISTINCT = 'meta::pure::functions::collection::distinct',
+  DATE_MAX = 'meta::pure::functions::date::max',
+  DATE_MIN = 'meta::pure::functions::date::min',
+  MAX = 'meta::pure::functions::math::max',
+  MIN = 'meta::pure::functions::math::min',
+  STD_DEV_POPULATION = 'meta::pure::functions::math::stdDevPopulation',
+  STD_DEV_SAMPLE = 'meta::pure::functions::math::stdDevSample',
+  SUM = 'meta::pure::functions::math::sum',
+  UNIQUE_VALUE_ONLY = 'meta::pure::functions::collection::uniqueValueOnly',
+}

package/src/graphManager/QueryBuilder_GraphManagerPlugin.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 packageJson from '../../package.json';
+import {
+  PureGraphManagerPlugin,
+  type PureGraphManagerExtensionBuilder,
+} from '@finos/legend-graph';
+import { QueryBuilder_buildGraphManagerExtension } from './protocol/pure/QueryBuilder_PureGraphManagerExtensionBuilder.js';
+
+export class QueryBuilder_PureGraphManagerPlugin extends PureGraphManagerPlugin {
+  constructor() {
+    super(packageJson.extensions.pureGraphManagerPlugin, packageJson.version);
+  }
+
+  override getExtraPureGraphManagerExtensionBuilders(): PureGraphManagerExtensionBuilder[] {
+    return [QueryBuilder_buildGraphManagerExtension];
+  }
+}

package/src/graphManager/QueryBuilder_GraphManagerPreset.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 packageJson from '../../package.json';
+import { AbstractPreset } from '@finos/legend-shared';
+import { QueryBuilder_PureProtocolProcessorPlugin } from './protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.js';
+import { QueryBuilder_PureGraphManagerPlugin } from './QueryBuilder_GraphManagerPlugin.js';
+
+/**
+ * This is the core graph manager preset and should not be exported
+ * and consumed outside of this package
+ */
+export class QueryBuilder_GraphManagerPreset extends AbstractPreset {
+  constructor() {
+    super(packageJson.extensions.graphManagerPreset, packageJson.version, [
+      new QueryBuilder_PureGraphManagerPlugin(),
+      new QueryBuilder_PureProtocolProcessorPlugin(),
+    ]);
+  }
+}

package/src/graphManager/action/analytics/MappingRuntimeCompatibilityAnalysis.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { Mapping, PackageableRuntime } from '@finos/legend-graph';
+
+export class MappingRuntimeCompatibilityAnalysisResult {
+  mapping!: Mapping;
+  runtimes: PackageableRuntime[] = [];
+}

package/src/graphManager/action/analytics/ServiceExecutionAnalysis.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { Service } from '@finos/legend-graph';
+
+export class ServiceExecutionAnalysisResult {
+  service!: Service;
+  executionKeys?: string[] | undefined;
+}

package/src/graphManager/protocol/pure/QueryBuilder_PureGraphManagerExtension.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { Entity } from '@finos/legend-storage';
+import {
+  type AbstractPureGraphManager,
+  AbstractPureGraphManagerExtension,
+} from '@finos/legend-graph';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import type { MappingRuntimeCompatibilityAnalysisResult } from '../../action/analytics/MappingRuntimeCompatibilityAnalysis.js';
+import type { ServiceExecutionAnalysisResult } from '../../action/analytics/ServiceExecutionAnalysis.js';
+
+export abstract class QueryBuilder_PureGraphManagerExtension extends AbstractPureGraphManagerExtension {
+  abstract surveyMappingRuntimeCompatibility(
+    entities: Entity[],
+    dependencyEntitiesIndex: Map<string, Entity[]>,
+  ): Promise<MappingRuntimeCompatibilityAnalysisResult[]>;
+
+  abstract surveyServiceExecution(
+    entities: Entity[],
+    dependencyEntitiesIndex: Map<string, Entity[]>,
+  ): Promise<ServiceExecutionAnalysisResult[]>;
+}
+
+export const getQueryBuilderGraphManagerExtension = (
+  graphManager: AbstractPureGraphManager,
+): QueryBuilder_PureGraphManagerExtension =>
+  guaranteeNonNullable(
+    graphManager.extensions.find(
+      (extension) =>
+        extension instanceof QueryBuilder_PureGraphManagerExtension,
+    ),
+    `Can't find query builder Pure graph manager extension`,
+  ) as QueryBuilder_PureGraphManagerExtension;

package/src/graphManager/protocol/pure/QueryBuilder_PureGraphManagerExtensionBuilder.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 type {
+  AbstractPureGraphManager,
+  AbstractPureGraphManagerExtension,
+} from '@finos/legend-graph';
+import { V1_QueryBuilder_PureGraphManagerExtension } from './v1/V1_QueryBuilder_PureGraphManagerExtension.js';
+
+export const QueryBuilder_buildGraphManagerExtension = (
+  graphManager: AbstractPureGraphManager,
+): AbstractPureGraphManagerExtension =>
+  // NOTE: until we support more client versions, we always default to return V1
+  new V1_QueryBuilder_PureGraphManagerExtension(graphManager);

package/src/graphManager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.ts

@@ -0,0 +1,167 @@
+/**
+ * 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 packageJson from '../../../../package.json';
+import {
+  V1_buildExistsFunctionExpression,
+  V1_buildFilterFunctionExpression,
+  V1_buildGetAllFunctionExpression,
+  V1_buildGroupByFunctionExpression,
+  V1_buildProjectFunctionExpression,
+} from './v1/V1_QueryBuilder_FunctionExpressionBuilder.js';
+import {
+  type V1_GraphBuilderContext,
+  type V1_ProcessingContext,
+  type V1_FunctionExpressionBuilder,
+  type V1_ValueSpecification,
+  type ValueSpecification,
+  type Type,
+  type V1_PropertyExpressionTypeInferrer,
+  PureProtocolProcessorPlugin,
+  matchFunctionName,
+  SimpleFunctionExpression,
+  extractElementNameFromPath,
+  V1_buildGenericFunctionExpression,
+} from '@finos/legend-graph';
+import { V1_buildSubTypePropertyExpressionTypeInference } from './v1/V1_QueryBuilder_PropertyExpressionTypeInferenceBuilder.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilderSupportedFunctions.js';
+
+export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
+  constructor() {
+    super(
+      packageJson.extensions.pureProtocolProcessorPlugin,
+      packageJson.version,
+    );
+  }
+
+  override V1_getExtraFunctionExpressionBuilders(): V1_FunctionExpressionBuilder[] {
+    return [
+      (
+        functionName: string,
+        parameters: V1_ValueSpecification[],
+        openVariables: string[],
+        compileContext: V1_GraphBuilderContext,
+        processingContext: V1_ProcessingContext,
+      ): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+        if (
+          matchFunctionName(
+            functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
+          )
+        ) {
+          return V1_buildGetAllFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
+        } else if (
+          matchFunctionName(functionName, [
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
+          ])
+        ) {
+          return V1_buildFilterFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
+        } else if (
+          matchFunctionName(
+            functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXISTS,
+          )
+        ) {
+          return V1_buildExistsFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
+        } else if (
+          matchFunctionName(
+            functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
+          )
+        ) {
+          return V1_buildProjectFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
+        } else if (
+          matchFunctionName(
+            functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
+          )
+        ) {
+          return V1_buildGroupByFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
+        } else if (
+          matchFunctionName(
+            functionName,
+            Object.values(QUERY_BUILDER_SUPPORTED_FUNCTIONS),
+          )
+        ) {
+          // NOTE: this is a catch-all builder that is only meant for basic function expression
+          // such as and(), or(), etc. It will fail when type-inferencing/function-matching is required
+          // such as for project(), filter(), getAll(), etc.
+          return V1_buildGenericFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraPropertyExpressionTypeInferrers(): V1_PropertyExpressionTypeInferrer[] {
+    return [
+      (inferredVariable: ValueSpecification | undefined): Type | undefined => {
+        let inferredType: Type | undefined =
+          inferredVariable?.genericType?.value.rawType;
+        if (
+          inferredVariable instanceof SimpleFunctionExpression &&
+          matchFunctionName(
+            inferredVariable.functionName,
+            extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+            ),
+          )
+        ) {
+          inferredType =
+            V1_buildSubTypePropertyExpressionTypeInference(inferredVariable);
+        }
+        return inferredType;
+      },
+    ];
+  }
+}