@finos/legend-application-repl 0.0.48 → 0.0.50

package/src/stores/dataCube/core/filter/DataCubeQueryFilterEditorState.ts

@@ -0,0 +1,229 @@
+/**
+ * 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 {
+  deepClone,
+  deleteEntry,
+  IllegalStateError,
+  uuid,
+} from '@finos/legend-shared';
+import { makeObservable, observable, action, isObservable } from 'mobx';
+import {
+  type DataCubeOperationValue,
+  DataCubeQueryFilterGroupOperator,
+} from '../DataCubeQueryEngine.js';
+import type {
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotFilter,
+  DataCubeQuerySnapshotFilterCondition,
+} from '../DataCubeQuerySnapshot.js';
+import type { DataCubeQueryFilterOperation } from './DataCubeQueryFilterOperation.js';
+
+export abstract class DataCubeFilterEditorTreeNode {
+  uuid = uuid();
+  parent: DataCubeFilterEditorConditionGroupTreeNode | undefined;
+  not = false;
+
+  constructor(
+    parent: DataCubeFilterEditorConditionGroupTreeNode | undefined,
+    not: boolean | undefined,
+  ) {
+    makeObservable(this, {
+      parent: observable,
+      setParent: action,
+
+      not: observable,
+      setNot: action,
+    });
+
+    this.parent = parent;
+    this.not = Boolean(not);
+  }
+
+  setNot(not: boolean) {
+    this.not = not;
+  }
+
+  setParent(parent: DataCubeFilterEditorConditionGroupTreeNode | undefined) {
+    this.parent = parent;
+  }
+}
+
+export class DataCubeFilterEditorConditionTreeNode extends DataCubeFilterEditorTreeNode {
+  column: DataCubeQuerySnapshotColumn;
+  operation: DataCubeQueryFilterOperation;
+  value: DataCubeOperationValue | undefined;
+
+  constructor(
+    parent: DataCubeFilterEditorConditionGroupTreeNode | undefined,
+    column: DataCubeQuerySnapshotColumn,
+    operation: DataCubeQueryFilterOperation,
+    value: DataCubeOperationValue | undefined,
+    not: boolean | undefined,
+  ) {
+    super(parent, not);
+
+    makeObservable(this, {
+      column: observable,
+      setColumn: action,
+
+      operation: observable,
+      setOperation: action,
+
+      value: observable.ref,
+      setValue: action,
+      updateValue: action,
+    });
+
+    this.column = column;
+    this.operation = operation;
+    this.setValue(value);
+  }
+
+  setColumn(col: DataCubeQuerySnapshotColumn) {
+    this.column = col;
+  }
+
+  setOperation(operation: DataCubeQueryFilterOperation) {
+    this.operation = operation;
+  }
+
+  setValue(value: DataCubeOperationValue | undefined) {
+    this.value = value
+      ? isObservable(value)
+        ? makeObservable(value, { value: observable })
+        : value
+      : undefined;
+  }
+
+  updateValue(value: unknown) {
+    if (this.value) {
+      this.value.value = value;
+    }
+  }
+}
+
+export class DataCubeFilterEditorConditionGroupTreeNode extends DataCubeFilterEditorTreeNode {
+  children: DataCubeFilterEditorTreeNode[] = [];
+  operation = DataCubeQueryFilterGroupOperator.AND;
+
+  constructor(
+    parent: DataCubeFilterEditorConditionGroupTreeNode | undefined,
+    operation: DataCubeQueryFilterGroupOperator,
+    not: boolean | undefined,
+  ) {
+    super(parent, not);
+
+    makeObservable(this, {
+      children: observable,
+      removeChild: action,
+      addChild: action,
+
+      operation: observable,
+      setOperation: action,
+    });
+
+    this.operation = operation;
+  }
+
+  setOperation(operation: DataCubeQueryFilterGroupOperator) {
+    this.operation = operation;
+  }
+
+  removeChild(node: DataCubeFilterEditorTreeNode): void {
+    const found = deleteEntry(this.children, node);
+    if (found) {
+      node.setParent(undefined);
+    }
+  }
+
+  addChild(node: DataCubeFilterEditorTreeNode, idx?: number | undefined): void {
+    if (!this.children.includes(node)) {
+      if (idx !== undefined) {
+        idx = Math.max(0, Math.min(idx, this.children.length));
+        this.children.splice(idx, 0, node);
+      } else {
+        this.children.push(node);
+      }
+      node.setParent(this);
+    }
+  }
+}
+export function buildFilterQuerySnapshot(
+  node: DataCubeFilterEditorConditionGroupTreeNode,
+): DataCubeQuerySnapshotFilter {
+  return {
+    groupOperator: node.operation,
+    not: node.not,
+    conditions: node.children.map((childNode) => {
+      if (childNode instanceof DataCubeFilterEditorConditionTreeNode) {
+        return {
+          name: childNode.column.name,
+          type: childNode.column.type,
+          operation: childNode.operation.operator,
+          value: deepClone(childNode.value),
+          not: childNode.not,
+        } satisfies DataCubeQuerySnapshotFilterCondition;
+      } else if (
+        childNode instanceof DataCubeFilterEditorConditionGroupTreeNode
+      ) {
+        return buildFilterQuerySnapshot(childNode);
+      }
+      throw new IllegalStateError('Unknown filter node');
+    }),
+  };
+}
+export function buildFilterEditorTree(
+  _node: DataCubeQuerySnapshotFilter,
+  parent: DataCubeFilterEditorConditionGroupTreeNode | undefined,
+  nodes: Map<string, DataCubeFilterEditorTreeNode>,
+  operationGetter: (operation: string) => DataCubeQueryFilterOperation,
+): DataCubeFilterEditorConditionGroupTreeNode {
+  const node = new DataCubeFilterEditorConditionGroupTreeNode(
+    parent,
+    _node.groupOperator === DataCubeQueryFilterGroupOperator.AND
+      ? DataCubeQueryFilterGroupOperator.AND
+      : DataCubeQueryFilterGroupOperator.OR,
+    _node.not,
+  );
+  _node.conditions.forEach((_childNode) => {
+    let childNode: DataCubeFilterEditorTreeNode;
+    if ('groupOperator' in _childNode) {
+      childNode = buildFilterEditorTree(
+        _childNode,
+        node,
+        nodes,
+        operationGetter,
+      );
+    } else {
+      childNode = new DataCubeFilterEditorConditionTreeNode(
+        node,
+        { name: _childNode.name, type: _childNode.type },
+        operationGetter(_childNode.operation),
+        _childNode.value,
+        _childNode.not,
+      );
+    }
+    node.addChild(childNode);
+    nodes.set(childNode.uuid, childNode);
+  });
+  nodes.set(node.uuid, node);
+  return node;
+}
+
+export type DataCubeFilterEditorTree = {
+  root?: DataCubeFilterEditorConditionGroupTreeNode | undefined;
+  nodes: Map<string, DataCubeFilterEditorTreeNode>;
+};

package/src/stores/dataCube/core/filter/DataCubeQueryFilterOperation.ts

@@ -0,0 +1,105 @@
+/**
+ * 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 { formatDate, UnsupportedOperationError } from '@finos/legend-shared';
+import type { DataCubeOperationValue } from '../DataCubeQueryEngine.js';
+import type {
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotFilterCondition,
+} from '../DataCubeQuerySnapshot.js';
+import {
+  DATE_FORMAT,
+  DATE_TIME_FORMAT,
+  PRIMITIVE_TYPE,
+  type V1_AppliedFunction,
+} from '@finos/legend-graph';
+
+// --------------------------------- UTILITIES ---------------------------------
+
+export function generateDefaultFilterConditionPrimitiveTypeValue(
+  type: string,
+): unknown {
+  switch (type) {
+    case PRIMITIVE_TYPE.STRING:
+      return '';
+    case PRIMITIVE_TYPE.BOOLEAN:
+      return false;
+    case PRIMITIVE_TYPE.BYTE:
+      return btoa('');
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT:
+    case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.BINARY:
+      return 0;
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return formatDate(new Date(Date.now()), DATE_FORMAT);
+    case PRIMITIVE_TYPE.DATETIME:
+      return formatDate(new Date(Date.now()), DATE_TIME_FORMAT);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't generate value for type '${type}'`,
+      );
+  }
+}
+
+export function ofType(
+  type: string,
+  targetTypes: ('string' | 'number' | 'boolean' | 'date')[],
+) {
+  switch (type) {
+    case PRIMITIVE_TYPE.STRING:
+      return targetTypes.includes('string');
+    case PRIMITIVE_TYPE.BOOLEAN:
+      return targetTypes.includes('boolean');
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT:
+    case PRIMITIVE_TYPE.INTEGER:
+      return targetTypes.includes('number');
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+    case PRIMITIVE_TYPE.DATETIME:
+      return targetTypes.includes('date');
+    default:
+      return false;
+  }
+}
+
+// --------------------------------- CONTRACT ---------------------------------
+
+export abstract class DataCubeQueryFilterOperation {
+  abstract get label(): React.ReactNode;
+  abstract get textLabel(): string;
+  abstract get description(): string;
+  abstract get operator(): string;
+
+  abstract isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn): boolean;
+  abstract isCompatibleWithValue(value: DataCubeOperationValue): boolean;
+
+  abstract generateDefaultValue(
+    column: DataCubeQuerySnapshotColumn,
+  ): DataCubeOperationValue | undefined;
+
+  abstract buildConditionSnapshot(
+    expression: V1_AppliedFunction,
+  ): DataCubeQuerySnapshotFilterCondition | undefined;
+
+  abstract buildConditionExpression(
+    condition: DataCubeQuerySnapshotFilterCondition,
+  ): V1_AppliedFunction | undefined;
+}

package/src/stores/dataCube/core/filter/DataCubeQueryFilterOperation__Contain.tsx

@@ -0,0 +1,87 @@
+/**
+ * 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 V1_AppliedFunction } from '@finos/legend-graph';
+import {
+  DataCubeQueryFilterOperation,
+  generateDefaultFilterConditionPrimitiveTypeValue,
+  ofType,
+} from './DataCubeQueryFilterOperation.js';
+import type {
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotFilterCondition,
+} from '../DataCubeQuerySnapshot.js';
+import {
+  DataCubeFunction,
+  DataCubeQueryFilterOperator,
+  type DataCubeOperationValue,
+} from '../DataCubeQueryEngine.js';
+import {
+  _function,
+  _functionName,
+  _property,
+  _value,
+} from '../DataCubeQueryBuilderUtils.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export class DataCubeQueryFilterOperation__Contain extends DataCubeQueryFilterOperation {
+  override get label() {
+    return 'contains';
+  }
+
+  override get textLabel() {
+    return 'contains';
+  }
+
+  override get description(): string {
+    return 'contains';
+  }
+
+  override get operator(): string {
+    return DataCubeQueryFilterOperator.CONTAIN;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofType(column.type, ['string']);
+  }
+
+  isCompatibleWithValue(value: DataCubeOperationValue) {
+    return (
+      ofType(value.type, ['string']) &&
+      value.value !== undefined &&
+      !Array.isArray(value.value)
+    );
+  }
+
+  generateDefaultValue(column: DataCubeQuerySnapshotColumn) {
+    return {
+      type: column.type,
+      value: generateDefaultFilterConditionPrimitiveTypeValue(column.type),
+    };
+  }
+
+  buildConditionSnapshot(expression: V1_AppliedFunction) {
+    // TODO: @akphi - implement this for roundtrip testing
+    return undefined;
+  }
+
+  buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {
+    return _function(_functionName(DataCubeFunction.CONTAINS), [
+      _property(condition.name),
+      _value(guaranteeNonNullable(condition.value)),
+    ]);
+  }
+}

package/src/stores/dataCube/core/filter/DataCubeQueryFilterOperation__ContainCaseInsensitive.tsx

@@ -0,0 +1,93 @@
+/**
+ * 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 V1_AppliedFunction } from '@finos/legend-graph';
+import {
+  DataCubeQueryFilterOperation,
+  generateDefaultFilterConditionPrimitiveTypeValue,
+  ofType,
+} from './DataCubeQueryFilterOperation.js';
+import type {
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotFilterCondition,
+} from '../DataCubeQuerySnapshot.js';
+import {
+  DataCubeFunction,
+  DataCubeQueryFilterOperator,
+  type DataCubeOperationValue,
+} from '../DataCubeQueryEngine.js';
+import {
+  _function,
+  _functionName,
+  _property,
+  _value,
+  _var,
+} from '../DataCubeQueryBuilderUtils.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export class DataCubeQueryFilterOperation__ContainCaseInsensitive extends DataCubeQueryFilterOperation {
+  override get label() {
+    return 'contains (case-insensitive)';
+  }
+
+  override get textLabel() {
+    return 'contains (case-insensitive)';
+  }
+
+  override get description(): string {
+    return 'contains (case-insensitive)';
+  }
+
+  override get operator(): string {
+    return DataCubeQueryFilterOperator.CONTAIN_CASE_INSENSITIVE;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofType(column.type, ['string']);
+  }
+
+  isCompatibleWithValue(value: DataCubeOperationValue) {
+    return (
+      ofType(value.type, ['string']) &&
+      value.value !== undefined &&
+      !Array.isArray(value.value)
+    );
+  }
+
+  generateDefaultValue(column: DataCubeQuerySnapshotColumn) {
+    return {
+      type: column.type,
+      value: generateDefaultFilterConditionPrimitiveTypeValue(column.type),
+    };
+  }
+
+  buildConditionSnapshot(expression: V1_AppliedFunction) {
+    // TODO: @akphi - implement this for roundtrip testing
+    return undefined;
+  }
+
+  buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {
+    const variable = _var();
+    return _function(_functionName(DataCubeFunction.CONTAINS), [
+      _function(_functionName(DataCubeFunction.TO_LOWERCASE), [
+        _property(condition.name, variable),
+      ]),
+      _function(_functionName(DataCubeFunction.TO_LOWERCASE), [
+        _value(guaranteeNonNullable(condition.value), variable),
+      ]),
+    ]);
+  }
+}

package/src/stores/dataCube/core/filter/DataCubeQueryFilterOperation__EndWith.tsx

@@ -0,0 +1,87 @@
+/**
+ * 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 V1_AppliedFunction } from '@finos/legend-graph';
+import {
+  DataCubeQueryFilterOperation,
+  generateDefaultFilterConditionPrimitiveTypeValue,
+  ofType,
+} from './DataCubeQueryFilterOperation.js';
+import type {
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotFilterCondition,
+} from '../DataCubeQuerySnapshot.js';
+import {
+  DataCubeFunction,
+  DataCubeQueryFilterOperator,
+  type DataCubeOperationValue,
+} from '../DataCubeQueryEngine.js';
+import {
+  _function,
+  _functionName,
+  _property,
+  _value,
+} from '../DataCubeQueryBuilderUtils.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export class DataCubeQueryFilterOperation__EndWith extends DataCubeQueryFilterOperation {
+  override get label() {
+    return 'ends with';
+  }
+
+  override get textLabel() {
+    return '!endsWith';
+  }
+
+  override get description(): string {
+    return 'ends with';
+  }
+
+  override get operator(): string {
+    return DataCubeQueryFilterOperator.END_WITH;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofType(column.type, ['string']);
+  }
+
+  isCompatibleWithValue(value: DataCubeOperationValue) {
+    return (
+      ofType(value.type, ['string']) &&
+      value.value !== undefined &&
+      !Array.isArray(value.value)
+    );
+  }
+
+  generateDefaultValue(column: DataCubeQuerySnapshotColumn) {
+    return {
+      type: column.type,
+      value: generateDefaultFilterConditionPrimitiveTypeValue(column.type),
+    };
+  }
+
+  buildConditionSnapshot(expression: V1_AppliedFunction) {
+    // TODO: @akphi - implement this for roundtrip testing
+    return undefined;
+  }
+
+  buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {
+    return _function(_functionName(DataCubeFunction.ENDS_WITH), [
+      _property(condition.name),
+      _value(guaranteeNonNullable(condition.value)),
+    ]);
+  }
+}

package/src/stores/dataCube/core/filter/DataCubeQueryFilterOperation__EndWithCaseInsensitive.tsx

@@ -0,0 +1,93 @@
+/**
+ * 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 V1_AppliedFunction } from '@finos/legend-graph';
+import {
+  DataCubeQueryFilterOperation,
+  generateDefaultFilterConditionPrimitiveTypeValue,
+  ofType,
+} from './DataCubeQueryFilterOperation.js';
+import type {
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotFilterCondition,
+} from '../DataCubeQuerySnapshot.js';
+import {
+  DataCubeFunction,
+  DataCubeQueryFilterOperator,
+  type DataCubeOperationValue,
+} from '../DataCubeQueryEngine.js';
+import {
+  _function,
+  _functionName,
+  _property,
+  _value,
+  _var,
+} from '../DataCubeQueryBuilderUtils.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export class DataCubeQueryFilterOperation__EndWithCaseInsensitive extends DataCubeQueryFilterOperation {
+  override get label() {
+    return 'ends with (case-insensitive)';
+  }
+
+  override get textLabel() {
+    return 'endsWith (case-insensitive)';
+  }
+
+  override get description(): string {
+    return 'ends with (case-insensitive)';
+  }
+
+  override get operator(): string {
+    return DataCubeQueryFilterOperator.END_WITH_CASE_INSENSITIVE;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofType(column.type, ['string']);
+  }
+
+  isCompatibleWithValue(value: DataCubeOperationValue) {
+    return (
+      ofType(value.type, ['string']) &&
+      value.value !== undefined &&
+      !Array.isArray(value.value)
+    );
+  }
+
+  generateDefaultValue(column: DataCubeQuerySnapshotColumn) {
+    return {
+      type: column.type,
+      value: generateDefaultFilterConditionPrimitiveTypeValue(column.type),
+    };
+  }
+
+  buildConditionSnapshot(expression: V1_AppliedFunction) {
+    // TODO: @akphi - implement this for roundtrip testing
+    return undefined;
+  }
+
+  buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {
+    const variable = _var();
+    return _function(_functionName(DataCubeFunction.ENDS_WITH), [
+      _function(_functionName(DataCubeFunction.TO_LOWERCASE), [
+        _property(condition.name, variable),
+      ]),
+      _function(_functionName(DataCubeFunction.TO_LOWERCASE), [
+        _value(guaranteeNonNullable(condition.value), variable),
+      ]),
+    ]);
+  }
+}