@finos/legend-application-data-cube 0.3.0 → 0.3.2

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -79,6 +79,9 @@ import {
   V1_TinyInt,
   V1_SmallInt,
   V1_serializePureModelContextData,
+  V1_deserializePureModelContext,
+  type V1_ConcreteFunctionDefinition,
+  V1_deserializeValueSpecification,
 } from '@finos/legend-graph';
 import {
   _elementPtr,
@@ -96,6 +99,8 @@ import {
   type DataCubeExecutionOptions,
   type DataCubeCacheInitializationOptions,
   DataCubeExecutionError,
+  RawUserDefinedFunctionDataCubeSource,
+  ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE,
 } from '@finos/legend-data-cube';
 import {
   isNonNullable,
@@ -223,6 +228,57 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         }
         return source;
       }
+      case ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE: {
+        const rawSource =
+          RawUserDefinedFunctionDataCubeSource.serialization.fromJson(value);
+        const deserializedModel = V1_deserializePureModelContext(
+          rawSource.model,
+        );
+
+        if (
+          rawSource.runtime === undefined ||
+          !(deserializedModel instanceof V1_PureModelContextPointer)
+        ) {
+          throw new Error(
+            `Unsupported user defined function source. Runtime is needed and model must be a pointer.`,
+          );
+        }
+
+        const source = new AdhocQueryDataCubeSource();
+        source.runtime = rawSource.runtime;
+        source.model = rawSource.model;
+        if (deserializedModel.sdlcInfo instanceof V1_LegendSDLC) {
+          const sdlcInfo = deserializedModel.sdlcInfo;
+          const fetchedFunction =
+            await this._depotServerClient.getVersionEntity(
+              sdlcInfo.groupId,
+              sdlcInfo.artifactId,
+              sdlcInfo.version,
+              rawSource.functionPath,
+            );
+          const functionContent =
+            fetchedFunction.content as V1_ConcreteFunctionDefinition;
+
+          //TODO add support for parameters
+          if (functionContent.body.length > 1) {
+            throw new Error(
+              `Unsupported user defined function source. Functions with parameters are not yet supported.`,
+            );
+          }
+
+          source.query = V1_deserializeValueSpecification(
+            functionContent.body[0] as PlainObject,
+            this._application.pluginManager.getPureProtocolProcessorPlugins(),
+          );
+          source.columns = (
+            await this._getLambdaRelationType(
+              this.serializeValueSpecification(_lambda([], [source.query])),
+              source.model,
+            )
+          ).columns;
+        }
+        return source;
+      }
       case LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE: {
         const rawSource =
           RawLegendQueryDataCubeSource.serialization.fromJson(value);

package/src/stores/builder/LegendDataCubeCreatorState.tsx

@@ -42,6 +42,7 @@ import {
 } from './LegendDataCubeBuilderStore.js';
 import { generateBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
 import { LocalFileDataCubeSourceBuilderState } from './source/LocalFileDataCubeSourceBuilderState.js';
+import { UserDefinedFunctionDataCubeSourceBuilderState } from './source/UserDefinedFunctionDataCubeSourceBuilderState.js';
 
 const DEFAULT_SOURCE_TYPE = LegendDataCubeSourceBuilderType.LEGEND_QUERY;
 
@@ -111,6 +112,12 @@ export class LegendDataCubeCreatorState {
           this._application,
           this._engine,
         );
+      case LegendDataCubeSourceBuilderType.USER_DEFINED_FUNCTION:
+        return new UserDefinedFunctionDataCubeSourceBuilderState(
+          this._application,
+          this._engine,
+          this._store,
+        );
       default:
         throw new UnsupportedOperationError(
           `Can't create source builder for unsupported type '${type}'`,

package/src/stores/builder/source/LegendDataCubeSourceBuilderState.ts

@@ -23,6 +23,7 @@ export enum LegendDataCubeSourceBuilderType {
   LEGEND_QUERY = 'Legend Query',
   ADHOC_QUERY = 'Ad hoc Query',
   LOCAL_FILE = 'Local File',
+  USER_DEFINED_FUNCTION = 'User Defined Function',
 }
 
 export abstract class LegendDataCubeSourceBuilderState {

package/src/stores/builder/source/UserDefinedFunctionDataCubeSourceBuilderState.ts

@@ -0,0 +1,176 @@
+/**
+ * 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 {
+  ActionState,
+  IllegalStateError,
+  assertErrorThrown,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  LegendDataCubeSourceBuilderState,
+  LegendDataCubeSourceBuilderType,
+} from './LegendDataCubeSourceBuilderState.js';
+import { StoreProjectData } from '@finos/legend-server-depot';
+import type { LegendDataCubeBuilderStore } from '../LegendDataCubeBuilderStore.js';
+import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
+import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseStore.js';
+import { action, flow, makeObservable, observable, runInAction } from 'mobx';
+import {
+  V1_LegendSDLC,
+  type V1_PackageableRuntime,
+  V1_PureModelContextPointer,
+  V1_serializePureModelContext,
+  type V1_ConcreteFunctionDefinition,
+} from '@finos/legend-graph';
+import {
+  type DataCubeConfiguration,
+  RawUserDefinedFunctionDataCubeSource,
+} from '@finos/legend-data-cube';
+
+export class UserDefinedFunctionDataCubeSourceBuilderState extends LegendDataCubeSourceBuilderState {
+  projects: StoreProjectData[] = [];
+  currentProject?: StoreProjectData | undefined;
+  currentProjectVersions?: string[] | undefined;
+  currentVersionId?: string | undefined;
+  builderStore: LegendDataCubeBuilderStore;
+  functions: V1_ConcreteFunctionDefinition[] | undefined;
+  currentFunction?: V1_ConcreteFunctionDefinition | undefined;
+  currentRuntime?: V1_PackageableRuntime | undefined;
+  runtimes?: V1_PackageableRuntime[] | undefined;
+
+  readonly loadProjectsState = ActionState.create();
+
+  constructor(
+    application: LegendDataCubeApplicationStore,
+    engine: LegendDataCubeDataCubeEngine,
+    builderStore: LegendDataCubeBuilderStore,
+  ) {
+    super(application, engine);
+    this.builderStore = builderStore;
+
+    makeObservable(this, {
+      loadProjects: flow,
+      currentFunction: observable,
+      projects: observable,
+      currentProject: observable,
+      currentProjectVersions: observable,
+      currentVersionId: observable,
+      currentRuntime: observable,
+      setCurrentProject: action,
+      setCurrentProjectVersions: action,
+      setCurrentVersionId: action,
+      setCurrentRuntime: action,
+    });
+  }
+
+  setCurrentProject(val: StoreProjectData | undefined): void {
+    this.currentProject = val;
+  }
+
+  setCurrentProjectVersions(val: string[] | undefined): void {
+    this.currentProjectVersions = val;
+  }
+
+  setCurrentVersionId(val: string | undefined): void {
+    this.currentVersionId = val;
+  }
+
+  getProjects(): StoreProjectData[] {
+    return this.projects;
+  }
+
+  setFunctions(val: V1_ConcreteFunctionDefinition[] | undefined): void {
+    this.functions = val;
+  }
+
+  setCurrentFunction(val: V1_ConcreteFunctionDefinition | undefined): void {
+    runInAction(() => {
+      this.currentFunction = val;
+    });
+  }
+
+  setCurrentRuntime(val: V1_PackageableRuntime | undefined): void {
+    this.currentRuntime = val;
+  }
+
+  setRuntimes(val: V1_PackageableRuntime[] | undefined): void {
+    this.runtimes = val;
+  }
+
+  *loadProjects() {
+    this.loadProjectsState.inProgress();
+    try {
+      this.projects = (
+        (yield this.builderStore.depotServerClient.getProjects()) as PlainObject<StoreProjectData>[]
+      ).map((v) => StoreProjectData.serialization.fromJson(v));
+      this.loadProjectsState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.builderStore.application.notificationService.notifyError(error);
+      this.loadProjectsState.fail();
+    }
+  }
+
+  override get label(): LegendDataCubeSourceBuilderType {
+    return LegendDataCubeSourceBuilderType.USER_DEFINED_FUNCTION;
+  }
+
+  override get isValid(): boolean {
+    return Boolean(
+      this.currentFunction &&
+        this.currentRuntime &&
+        this.currentProject &&
+        this.currentVersionId,
+    );
+  }
+
+  override async generateSourceData(): Promise<PlainObject> {
+    if (!this.isValid) {
+      throw new IllegalStateError(
+        `Can't generate source data: project, version, function, or runtime are not set`,
+      );
+    }
+
+    const source = new RawUserDefinedFunctionDataCubeSource();
+    if (
+      this.currentProject &&
+      this.currentVersionId &&
+      this.currentRuntime &&
+      this.currentFunction
+    ) {
+      source.functionPath = this.currentFunction.path;
+      source.runtime = this.currentRuntime.path;
+      const sdlc = new V1_LegendSDLC(
+        this.currentProject.groupId,
+        this.currentProject.artifactId,
+        this.currentVersionId,
+      );
+      const modelContextPointer = new V1_PureModelContextPointer(
+        undefined,
+        sdlc,
+      );
+      source.model = V1_serializePureModelContext(modelContextPointer);
+    }
+    return RawUserDefinedFunctionDataCubeSource.serialization.toJson(source);
+  }
+
+  override finalizeConfiguration(configuration: DataCubeConfiguration) {
+    if (this.currentFunction) {
+      configuration.name = this.currentFunction.name;
+    }
+  }
+}

package/tsconfig.json

@@ -68,6 +68,7 @@
     "./src/stores/builder/source/LegendDataCubeSourceBuilderState.ts",
     "./src/stores/builder/source/LegendQueryDataCubeSourceBuilderState.ts",
     "./src/stores/builder/source/LocalFileDataCubeSourceBuilderState.ts",
+    "./src/stores/builder/source/UserDefinedFunctionDataCubeSourceBuilderState.ts",
     "./src/stores/model/LegendQueryDataCubeSource.ts",
     "./src/stores/model/LocalFileDataCubeSource.ts",
     "./src/application/LegendDataCube.tsx",
@@ -84,6 +85,7 @@
     "./src/components/builder/source/AdhocQueryDataCubeSourceBuilder.tsx",
     "./src/components/builder/source/LegendQueryDataCubeSourceBuilder.tsx",
     "./src/components/builder/source/LocalFileDataCubeSourceBuilder.tsx",
+    "./src/components/builder/source/UserDefinedFunctionDataCubeSourceBuilder.tsx",
     "./src/stores/builder/LegendDataCubeBuilderStore.tsx",
     "./src/stores/builder/LegendDataCubeCreatorState.tsx",
     "./src/stores/builder/LegendDataCubeLoaderState.tsx"