@finos/legend-application-data-cube 0.1.0

package/src/stores/LegendDataCubeEditorStore.ts

@@ -0,0 +1,120 @@
+/**
+ * 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 {
+  DEFAULT_TAB_SIZE,
+  type ApplicationStore,
+} from '@finos/legend-application';
+import type { LegendDataCubePluginManager } from '../application/LegendDataCubePluginManager.js';
+import { DepotServerClient } from '@finos/legend-server-depot';
+import type { LegendDataCubeApplicationConfig } from '../application/LegendDataCubeApplicationConfig.js';
+import { GraphManagerState } from '@finos/legend-graph';
+import { LegendDataCubeSourceBuilder } from './source/LegendDataCubeSourceBuilder.js';
+import {
+  ActionState,
+  assertErrorThrown,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { action, flow, makeObservable, observable } from 'mobx';
+import { LegendCubeViewer } from './source/LegendCubeViewer.js';
+import type { CubeInputSource } from './source/CubeInputSource.js';
+import type { DataCubeEngine } from '@finos/legend-data-cube';
+
+export type LegendDataCubeApplicationStore = ApplicationStore<
+  LegendDataCubeApplicationConfig,
+  LegendDataCubePluginManager
+>;
+
+export class LegendDataCubeStoreContext {
+  readonly applicationStore: LegendDataCubeApplicationStore;
+  readonly depotServerClient: DepotServerClient;
+  readonly graphManagerState: GraphManagerState;
+  initState = ActionState.create();
+
+  constructor(applicationStore: LegendDataCubeApplicationStore) {
+    makeObservable(this, {
+      initialize: flow,
+      initState: observable,
+    });
+    // server
+    this.depotServerClient = new DepotServerClient({
+      serverUrl: applicationStore.config.depotServerUrl,
+    });
+    this.depotServerClient.setTracerService(applicationStore.tracerService);
+    this.graphManagerState = new GraphManagerState(
+      applicationStore.pluginManager,
+      applicationStore.logService,
+    );
+    this.applicationStore = applicationStore;
+  }
+
+  *initialize(): GeneratorFn<void> {
+    if (!this.initState.isInInitialState) {
+      return;
+    }
+
+    try {
+      this.initState.inProgress();
+      // TODO: when we genericize the way to initialize an application page
+      this.applicationStore.assistantService.setIsHidden(true);
+
+      // initialize the graph manager
+      yield this.graphManagerState.graphManager.initialize(
+        {
+          env: this.applicationStore.config.env,
+          tabSize: DEFAULT_TAB_SIZE,
+          clientConfig: {
+            baseUrl: this.applicationStore.config.engineServerUrl,
+            queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
+            enableCompression: true,
+          },
+        },
+        {
+          tracerService: this.applicationStore.tracerService,
+        },
+      );
+      this.initState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(error);
+      this.initState.fail();
+    }
+  }
+}
+
+export class LegendDataCubeStore {
+  readonly applicationStore: LegendDataCubeApplicationStore;
+  readonly context: LegendDataCubeStoreContext;
+  readonly pluginManager: LegendDataCubePluginManager;
+  sourceSelector: LegendDataCubeSourceBuilder;
+  cubeViewer: LegendCubeViewer | undefined;
+
+  constructor(applicationStore: LegendDataCubeApplicationStore) {
+    makeObservable(this, {
+      cubeViewer: observable,
+      sourceSelector: observable,
+      initializeView: action,
+    });
+    this.applicationStore = applicationStore;
+    this.pluginManager = applicationStore.pluginManager;
+    this.context = new LegendDataCubeStoreContext(applicationStore);
+    this.sourceSelector = new LegendDataCubeSourceBuilder(this.context);
+  }
+
+  initializeView(source: CubeInputSource, engine: DataCubeEngine): void {
+    this.cubeViewer = new LegendCubeViewer(source, engine);
+  }
+}

package/src/stores/engine/LegendExecutionDataCubeEngine.ts

@@ -0,0 +1,257 @@
+/**
+ * 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 {
+  SUPPORTED_FUNCTIONS,
+  V1_AppliedFunction,
+  V1_Lambda,
+  RawLambda,
+  RelationalExecutionActivities,
+  TDSExecutionResult,
+  V1_deserializeRawValueSpecification,
+  V1_deserializeValueSpecification,
+  V1_RawLambda,
+  V1_serializeValueSpecification,
+  type GraphManagerState,
+  type PureModel,
+  type V1_ValueSpecification,
+  type ParameterValue,
+} from '@finos/legend-graph';
+import {
+  _elementPtr,
+  _functionName,
+  DataCubeEngine,
+  DataCubeSource,
+  type RelationType,
+  DataCubeQuery,
+  type DataCubeInitialInput,
+  type CompletionItem,
+  _function,
+  DataCubeFunction,
+} from '@finos/legend-data-cube';
+import { guaranteeType, isNonNullable, LogService } from '@finos/legend-shared';
+
+class QueryBuilderDataCubeSource extends DataCubeSource {
+  mapping?: string | undefined;
+  runtime!: string;
+}
+
+export class LegendExecutionDataCubeEngine extends DataCubeEngine {
+  readonly logService = new LogService();
+  readonly graphState: GraphManagerState;
+  readonly selectInitialQuery: RawLambda;
+  readonly mappingPath: string | undefined;
+  readonly parameterValues: ParameterValue[] | undefined;
+  readonly runtimePath: string;
+  _parameters: object | undefined;
+
+  constructor(
+    selectQuery: RawLambda,
+    parameterValues: ParameterValue[] | undefined,
+    mappingPath: string | undefined,
+    runtimePath: string,
+    graphManagerState: GraphManagerState,
+  ) {
+    super();
+    this.graphState = graphManagerState;
+    this.selectInitialQuery = selectQuery;
+    this.mappingPath = mappingPath;
+    this.runtimePath = runtimePath;
+    this.parameterValues = parameterValues;
+  }
+
+  get sourceLabel(): string {
+    return `Query Builder Report`;
+  }
+
+  override getInitialInput(): Promise<DataCubeInitialInput> {
+    return this.buildBaseQuery();
+  }
+
+  async buildBaseQuery(): Promise<DataCubeInitialInput> {
+    let srcFuncExp = V1_deserializeValueSpecification(
+      this.graphState.graphManager.serializeRawValueSpecification(
+        this.selectInitialQuery,
+      ),
+      [],
+    );
+    // We could do a further check here to ensure the experssion is an applied funciton
+    // this is because data cube expects an expression to be able to built further upon the queery
+    if (
+      srcFuncExp instanceof V1_Lambda &&
+      srcFuncExp.body.length === 1 &&
+      srcFuncExp.body[0]
+    ) {
+      srcFuncExp = srcFuncExp.body[0];
+    }
+    this._parameters = this.selectInitialQuery.parameters;
+    const fromFuncExp = new V1_AppliedFunction();
+    fromFuncExp.function = _functionName(SUPPORTED_FUNCTIONS.FROM);
+    fromFuncExp.parameters = [srcFuncExp];
+    if (this.mappingPath) {
+      fromFuncExp.parameters.push(_elementPtr(this.mappingPath));
+    }
+    if (this.runtimePath) {
+      fromFuncExp.parameters.push(_elementPtr(this.runtimePath));
+    }
+    const columns = (await this.getRelationalType(this.selectInitialQuery))
+      .columns;
+    const query = new DataCubeQuery();
+    query.query = `~[${columns.map((e) => `'${e.name}'`)}]->select()`;
+    const source = new QueryBuilderDataCubeSource();
+    source.sourceColumns = columns;
+    source.mapping = this.mappingPath;
+    source.runtime = this.runtimePath;
+    source.query = srcFuncExp;
+    return {
+      query,
+      source,
+    };
+  }
+
+  get graph(): PureModel {
+    return this.graphState.graph;
+  }
+
+  private buildRawLambdaFromValueSpec(query: V1_Lambda): RawLambda {
+    const json = guaranteeType(
+      V1_deserializeRawValueSpecification(
+        V1_serializeValueSpecification(query, []),
+      ),
+      V1_RawLambda,
+    );
+    return new RawLambda(json.parameters, json.body);
+  }
+
+  async getQueryTypeahead(
+    code: string,
+    baseQuery: V1_Lambda,
+    source: DataCubeSource,
+  ) {
+    const lambda = this.buildRawLambdaFromValueSpec(baseQuery);
+    const queryString =
+      await this.graphState.graphManager.lambdaToPureCode(lambda);
+    let codeBlock = queryString + code;
+    if (codeBlock[0] === '|') {
+      codeBlock = codeBlock.substring(1);
+    }
+    const result = await this.graphState.graphManager.getCodeComplete(
+      codeBlock,
+      this.graph,
+      undefined,
+    );
+    return result.completions as CompletionItem[];
+  }
+
+  override async parseValueSpecification(
+    code: string,
+    returnSourceInformation?: boolean,
+  ) {
+    return V1_deserializeValueSpecification(
+      await this.graphState.graphManager.pureCodeToValueSpecification(
+        code,
+        returnSourceInformation,
+      ),
+      [],
+    );
+  }
+
+  override getValueSpecificationCode(
+    value: V1_ValueSpecification,
+    pretty?: boolean | undefined,
+  ) {
+    return this.graphState.graphManager.valueSpecificationToPureCode(
+      V1_serializeValueSpecification(value, []),
+      pretty,
+    );
+  }
+
+  private async getRelationalType(query: RawLambda): Promise<RelationType> {
+    const relationType =
+      await this.graphState.graphManager.getLambdaRelationType(
+        query,
+        this.graph,
+      );
+    return relationType;
+  }
+
+  override getQueryRelationType(query: V1_Lambda, source: DataCubeSource) {
+    const lambda = this.buildRawLambdaFromValueSpec(query);
+    return this.getRelationalType(lambda);
+  }
+
+  override async getQueryCodeRelationReturnType(
+    code: string,
+    baseQuery: V1_ValueSpecification,
+    source: DataCubeSource,
+  ) {
+    const queryString =
+      await this.graphState.graphManager.valueSpecificationToPureCode(
+        V1_serializeValueSpecification(baseQuery, []),
+      );
+    const fullQuery = queryString + code;
+    return this.getRelationalType(
+      await this.graphState.graphManager.pureCodeToLambda(fullQuery),
+    );
+  }
+
+  override async executeQuery(query: V1_Lambda, source: DataCubeSource) {
+    const lambda = this.buildRawLambdaFromValueSpec(query);
+    lambda.parameters = this._parameters;
+    const [executionWithMetadata, queryString] = await Promise.all([
+      this.graphState.graphManager.runQuery(
+        lambda,
+        undefined,
+        undefined,
+        this.graph,
+        {
+          parameterValues: this.parameterValues ?? [],
+        },
+      ),
+      this.graphState.graphManager.lambdaToPureCode(lambda),
+    ]);
+    const expectedTDS = guaranteeType(
+      executionWithMetadata.executionResult,
+      TDSExecutionResult,
+      'Query returned expected to be of tabular data set',
+    );
+    const sql = expectedTDS.activities?.[0];
+    let sqlString = '### NO SQL FOUND';
+    if (sql instanceof RelationalExecutionActivities) {
+      sqlString = sql.sql;
+    }
+    return {
+      result: expectedTDS,
+      executedQuery: queryString,
+      executedSQL: sqlString,
+    };
+  }
+
+  override buildExecutionContext(
+    source: DataCubeSource,
+  ): V1_AppliedFunction | undefined {
+    if (source instanceof QueryBuilderDataCubeSource) {
+      return _function(
+        DataCubeFunction.FROM,
+        [
+          source.mapping ? _elementPtr(source.mapping) : undefined,
+          _elementPtr(source.runtime),
+        ].filter(isNonNullable),
+      );
+    }
+    return undefined;
+  }
+}

package/src/stores/source/CubeInputSource.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 { VersionedProjectData } from '@finos/legend-server-depot';
+
+export abstract class CubeInputSource {}
+
+export abstract class LegendDepotSavedSource {
+  project!: VersionedProjectData;
+}
+
+export class LegendSavedQuerySource extends CubeInputSource {
+  id: string;
+
+  constructor(id: string) {
+    super();
+    this.id = id;
+  }
+}
+
+export class LegendDepotService extends LegendDepotSavedSource {
+  service!: string;
+}
+
+export class LegendDepotFunction extends LegendDepotSavedSource {
+  _function!: string;
+}
+
+export class LegendDepotTable extends LegendDepotSavedSource {
+  database!: string;
+  schema!: string;
+  table!: string;
+  runtime!: string;
+}

package/src/stores/source/CubeInputSourceLoader.ts

@@ -0,0 +1,56 @@
+/**
+ * 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, UnsupportedOperationError } from '@finos/legend-shared';
+import { type CubeInputSource } from './CubeInputSource.js';
+import type { DataCubeEngine } from '@finos/legend-data-cube';
+import type { LegendDataCubeStoreContext } from '../LegendDataCubeEditorStore.js';
+
+export enum DataCubeSourceType {
+  LEGEND_QUERY = 'Legend Query',
+  DEPOT_QUERY = 'Depot Query',
+}
+
+export abstract class CubeInputSourceState {
+  buildCubeEngineState = ActionState.create();
+
+  setupActionState = ActionState.create();
+
+  readonly context: LegendDataCubeStoreContext;
+
+  constructor(context: LegendDataCubeStoreContext) {
+    this.context = context;
+  }
+  abstract get label(): DataCubeSourceType;
+
+  async setup(): Promise<void> {
+    this.setupActionState.complete();
+  }
+
+  abstract buildCubeEngine(): Promise<DataCubeEngine | undefined>;
+
+  abstract process(): CubeInputSource;
+
+  abstract get isValid(): boolean;
+
+  get openActionable(): boolean {
+    return true;
+  }
+
+  static builder(context: LegendDataCubeStoreContext): CubeInputSourceState {
+    throw new UnsupportedOperationError('No builder');
+  }
+}

package/src/stores/source/LegendCubeViewer.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { DataCubeEngine } from '@finos/legend-data-cube';
+import type { CubeInputSource } from './CubeInputSource.js';
+
+export class LegendCubeViewer {
+  source: CubeInputSource;
+  engine: DataCubeEngine;
+
+  constructor(source: CubeInputSource, engine: DataCubeEngine) {
+    this.source = source;
+    this.engine = engine;
+  }
+}

package/src/stores/source/LegendDataCubeSourceBuilder.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 { flow, makeObservable, observable } from 'mobx';
+import {
+  DataCubeSourceType,
+  type CubeInputSourceState,
+} from './CubeInputSourceLoader.js';
+import { SavedQueryInputSourceState } from './SavedQueryInputSourceState.js';
+import type { LegendDataCubeStoreContext } from '../LegendDataCubeEditorStore.js';
+import {
+  UnsupportedOperationError,
+  assertErrorThrown,
+  assertTrue,
+  guaranteeNonNullable,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import type { CubeInputSource } from './CubeInputSource.js';
+import type { DataCubeEngine } from '@finos/legend-data-cube';
+
+export class LegendDataCubeSourceBuilder {
+  readonly context: LegendDataCubeStoreContext;
+  open = false;
+  sourceState: CubeInputSourceState;
+
+  constructor(context: LegendDataCubeStoreContext) {
+    makeObservable(this, {
+      open: observable,
+      sourceState: observable,
+      inputSource: flow,
+    });
+    this.context = context;
+    this.sourceState = this.buildSource(guaranteeNonNullable(this.options[0]));
+  }
+
+  get options(): DataCubeSourceType[] {
+    return Object.values(DataCubeSourceType);
+  }
+
+  get currentOption(): DataCubeSourceType {
+    throw new UnsupportedOperationError('');
+  }
+
+  openModal(): void {
+    this.open = true;
+  }
+
+  close(): void {
+    this.open = false;
+  }
+
+  changeSource(source: DataCubeSourceType): void {
+    if (this.sourceState.label !== source) {
+      this.sourceState = this.buildSource(source);
+    }
+  }
+
+  buildSource(source: DataCubeSourceType): CubeInputSourceState {
+    if (source === DataCubeSourceType.LEGEND_QUERY) {
+      return SavedQueryInputSourceState.builder(this.context);
+    }
+    throw new UnsupportedOperationError('Not supported');
+  }
+
+  *inputSource(
+    callback: (source: CubeInputSource, engine: DataCubeEngine) => void,
+  ): GeneratorFn<void> {
+    try {
+      assertTrue(
+        this.sourceState.isValid,
+        'Source State is in a valid state to input',
+      );
+      const engine =
+        (yield this.sourceState.buildCubeEngine()) as DataCubeEngine;
+      const source = this.sourceState.process();
+      callback(source, engine);
+      this.close();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.context.applicationStore.notificationService.notifyError(
+        `Unable to import: ${this.sourceState.label}: ${error.message}`,
+      );
+    }
+  }
+}