@finos/legend-application-data-cube 0.1.6 → 0.1.7

package/src/components/source/SavedQuerySourceEditor.tsx

@@ -1,62 +0,0 @@
-/**
- * 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 { observer } from 'mobx-react-lite';
-import { QueryLoader } from '@finos/legend-query-builder';
-import type { SavedQueryInputSourceState } from '../../stores/source/SavedQueryInputSourceState.js';
-import { generateGAVCoordinates } from '@finos/legend-storage';
-
-export const SavedQuerySourceEditor = observer(
-  (props: { savedQueryInputSourceState: SavedQueryInputSourceState }) => {
-    const { savedQueryInputSourceState } = props;
-    const savedQuery = savedQueryInputSourceState.query;
-
-    return (
-      <div>
-        {savedQuery ? (
-          <div className="p-3">
-            <div className="text-l font-bold">Saved Query</div>
-            <div>
-              <div className="flex pt-px">
-                <div className="font-bold">Name:</div>
-                <div>{savedQuery.name}</div>
-              </div>
-              <div className="flex pt-px">
-                <div className="font-bold">Project:</div>
-                <div>
-                  {generateGAVCoordinates(
-                    savedQuery.groupId,
-                    savedQuery.artifactId,
-                    savedQuery.versionId,
-                  )}
-                </div>
-              </div>
-              <div className="flex pt-px">
-                <div className="font-bold">Owner:</div>
-                <div>{savedQuery.owner}</div>
-              </div>
-            </div>
-          </div>
-        ) : (
-          <QueryLoader
-            queryLoaderState={savedQueryInputSourceState.queryLoaderState}
-            loadActionLabel={'Open'}
-          />
-        )}
-      </div>
-    );
-  },
-);

package/src/stores/LegendDataCubeEditorStore.ts

@@ -1,237 +0,0 @@
-/**
- * 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, resolveVersion } from '@finos/legend-server-depot';
-import type { LegendDataCubeApplicationConfig } from '../application/LegendDataCubeApplicationConfig.js';
-import {
-  GraphManagerState,
-  LegendSDLC,
-  PersistentDataCubeQuery,
-  type QueryInfo,
-  type RawLambda,
-} from '@finos/legend-graph';
-import { LegendDataCubeSourceBuilder } from './source/LegendDataCubeSourceBuilder.js';
-import {
-  ActionState,
-  UnsupportedOperationError,
-  assertErrorThrown,
-  guaranteeNonNullable,
-  uuid,
-  type GeneratorFn,
-} from '@finos/legend-shared';
-import { action, flow, flowResult, makeObservable, observable } from 'mobx';
-import { LegendCubeViewer } from './source/LegendCubeViewer.js';
-import type { DataCubeEngine } from '@finos/legend-data-cube';
-import type { DataCubeGenericSource } from './model/DataCubeGenericSource.js';
-import {
-  createQueryBuilderContent,
-  deserializeDataCubeQueryConent,
-  serializeDataCubeQueryConent,
-} from './model/DataCubeGenericSourceHelper.js';
-import { LegendSavedQuerySource } from './model/LegendSavedQuerySource.js';
-import { LegendExecutionDataCubeEngine } from './engine/LegendExecutionDataCubeEngine.js';
-import { generatedSavedQueryUrl } from '../__lib__/LegendDataCubeNavigation.js';
-
-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;
-  saveModal = false;
-  saveModalState = ActionState.create();
-  savedQuery: PersistentDataCubeQuery | undefined;
-
-  constructor(applicationStore: LegendDataCubeApplicationStore) {
-    makeObservable(this, {
-      cubeViewer: observable,
-      sourceSelector: observable,
-      saveModal: observable,
-      setSaveModal: observable,
-      saveModalState: observable,
-      savedQuery: observable,
-      initializeView: action,
-      initialize: flow,
-      saveQuery: flow,
-    });
-    this.applicationStore = applicationStore;
-    this.pluginManager = applicationStore.pluginManager;
-    this.context = new LegendDataCubeStoreContext(applicationStore);
-    this.sourceSelector = new LegendDataCubeSourceBuilder(this.context);
-  }
-
-  setSaveModal(val: boolean): void {
-    this.saveModal = val;
-  }
-
-  initializeView(source: DataCubeGenericSource, engine: DataCubeEngine): void {
-    this.cubeViewer = new LegendCubeViewer(source, engine);
-  }
-
-  *initialize(id: string): GeneratorFn<void> {
-    try {
-      yield flowResult(this.context.initialize());
-      const query =
-        (yield this.context.graphManagerState.graphManager.getDataCubeQuery(
-          id,
-        )) as unknown as PersistentDataCubeQuery;
-      this.savedQuery = query;
-      const source = deserializeDataCubeQueryConent(query.content).source;
-      if (source instanceof LegendSavedQuerySource) {
-        const queryInfo =
-          (yield this.context.graphManagerState.graphManager.getQueryInfo(
-            source.id,
-          )) as unknown as QueryInfo;
-        const execConext =
-          (yield this.context.graphManagerState.graphManager.resolveQueryInfoExecutionContext(
-            queryInfo,
-            () =>
-              this.context.depotServerClient.getVersionEntities(
-                queryInfo.groupId,
-                queryInfo.artifactId,
-                queryInfo.versionId,
-              ),
-          )) as { mapping: string | undefined; runtime: string };
-        const lambda =
-          (yield this.context.graphManagerState.graphManager.pureCodeToLambda(
-            queryInfo.content,
-          )) as unknown as RawLambda;
-        this.context.graphManagerState.graph.setOrigin(
-          new LegendSDLC(
-            queryInfo.groupId,
-            queryInfo.artifactId,
-            resolveVersion(queryInfo.versionId),
-          ),
-        );
-        // TODO: we should be able to call engine and convert lambda to relation if not one.
-        const engine = new LegendExecutionDataCubeEngine(
-          lambda,
-          undefined,
-          execConext.mapping,
-          execConext.runtime,
-          this.context.graphManagerState,
-        );
-        this.initializeView(source, engine);
-      } else {
-        throw new UnsupportedOperationError('not supported');
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.applicationStore.notificationService.notifyError(
-        `Unable to initialie query with id '${id}'`,
-      );
-    }
-  }
-
-  *saveQuery(name: string): GeneratorFn<void> {
-    try {
-      this.saveModalState.inProgress();
-      const view = guaranteeNonNullable(this.cubeViewer);
-      const content = serializeDataCubeQueryConent(
-        createQueryBuilderContent(view.source),
-      );
-      const cubeQuery = new PersistentDataCubeQuery();
-      cubeQuery.content = content;
-      cubeQuery.name = name;
-      cubeQuery.id = uuid();
-      const querySaved =
-        (yield this.context.graphManagerState.graphManager.createQueryDataCube(
-          cubeQuery,
-        )) as unknown as PersistentDataCubeQuery;
-      this.savedQuery = querySaved;
-      // TODO: fix reload
-      this.applicationStore.navigationService.navigator.goToLocation(
-        generatedSavedQueryUrl(querySaved.id),
-      );
-      this.setSaveModal(false);
-      this.saveModalState.complete();
-    } catch (error) {
-      assertErrorThrown(error);
-      this.saveModalState.fail();
-      this.applicationStore.notificationService.notifyError(
-        `Unable to save query`,
-      );
-    }
-  }
-}

package/src/stores/engine/LegendExecutionDataCubeEngine.ts

@@ -1,267 +0,0 @@
-/**
- * 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 CompletionItem,
-  _function,
-  DataCubeFunction,
-} from '@finos/legend-data-cube';
-import {
-  guaranteeType,
-  isNonNullable,
-  LogService,
-  type PlainObject,
-} 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`;
-  }
-
-  get graph(): PureModel {
-    return this.graphState.graph;
-  }
-
-  private getSourceFunctionExpression() {
-    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];
-    }
-    return srcFuncExp;
-  }
-
-  async getBaseQuery() {
-    const srcFuncExp = this.getSourceFunctionExpression();
-    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()`;
-
-    return query;
-  }
-
-  async processQuerySource(value: PlainObject) {
-    const srcFuncExp = this.getSourceFunctionExpression();
-    const columns = (await this.getRelationalType(this.selectInitialQuery))
-      .columns;
-    const source = new QueryBuilderDataCubeSource();
-    source.sourceColumns = columns;
-    source.mapping = this.mappingPath;
-    source.runtime = this.runtimePath;
-    source.query = srcFuncExp;
-    return source;
-  }
-
-  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[];
-  }
-
-  async parseValueSpecification(
-    code: string,
-    returnSourceInformation?: boolean,
-  ) {
-    return V1_deserializeValueSpecification(
-      await this.graphState.graphManager.pureCodeToValueSpecification(
-        code,
-        returnSourceInformation,
-      ),
-      [],
-    );
-  }
-
-  async 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;
-  }
-
-  async getQueryRelationType(query: V1_Lambda, source: DataCubeSource) {
-    const lambda = this.buildRawLambdaFromValueSpec(query);
-    return this.getRelationalType(lambda);
-  }
-
-  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),
-    );
-  }
-
-  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,
-    };
-  }
-
-  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/model/DataCubeGenericSourceHelper.ts

@@ -1,97 +0,0 @@
-/**
- * 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 {
-  UnsupportedOperationError,
-  optionalCustom,
-  usingConstantValueSchema,
-  type PlainObject,
-} from '@finos/legend-shared';
-import type { DataCubeGenericSource } from './DataCubeGenericSource.js';
-import { LegendSavedQuerySource } from './LegendSavedQuerySource.js';
-import {
-  createModelSchema,
-  primitive,
-  deserialize,
-  serialize,
-  optional,
-  raw,
-} from 'serializr';
-import { DataCubeQueryConent } from './DataCubeQueryContent.js';
-
-enum SavedDataCubeQueryType {
-  LEGEND_QUERY = 'LegendQuery',
-}
-
-export const legendSavedQuerySourceModelSchema = createModelSchema(
-  LegendSavedQuerySource,
-  {
-    _type: usingConstantValueSchema(SavedDataCubeQueryType.LEGEND_QUERY),
-    id: primitive(),
-  },
-);
-
-const deserializeDataCubeGenericSource = (
-  content: PlainObject<object>,
-): DataCubeGenericSource => {
-  switch (content._type) {
-    case SavedDataCubeQueryType.LEGEND_QUERY:
-      return deserialize(legendSavedQuerySourceModelSchema, content);
-    default:
-  }
-  throw new UnsupportedOperationError(
-    `Can't de serialize saved data cube`,
-    content._type,
-  );
-};
-
-const serializeDataCubeGenericSource = (
-  genericSource: DataCubeGenericSource,
-): PlainObject<DataCubeGenericSource> => {
-  if (genericSource instanceof LegendSavedQuerySource) {
-    return serialize(legendSavedQuerySourceModelSchema, genericSource);
-  }
-  throw new UnsupportedOperationError(`Can't serialize saved data cube`);
-};
-
-const dataCubeQueryConentModelSchema = createModelSchema(DataCubeQueryConent, {
-  query: optional(primitive()),
-  configuration: optional(raw()),
-  source: optionalCustom(
-    (val) => serializeDataCubeGenericSource(val),
-    (val) => deserializeDataCubeGenericSource(val),
-  ),
-});
-
-export const createQueryBuilderContent = (
-  source: DataCubeGenericSource,
-): DataCubeQueryConent => {
-  const content = new DataCubeQueryConent();
-  content.source = source;
-  return content;
-};
-
-export const serializeDataCubeQueryConent = (
-  content: DataCubeQueryConent,
-): PlainObject<DataCubeQueryConent> => {
-  return serialize(dataCubeQueryConentModelSchema, content);
-};
-
-export const deserializeDataCubeQueryConent = (
-  content: PlainObject<DataCubeQueryConent>,
-): DataCubeQueryConent => {
-  return deserialize(dataCubeQueryConentModelSchema, content);
-};

package/src/stores/model/LegendSavedQuerySource.ts

@@ -1,26 +0,0 @@
-/**
- * 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 { DataCubeGenericSource } from './DataCubeGenericSource.js';
-
-export class LegendSavedQuerySource extends DataCubeGenericSource {
-  id: string;
-
-  constructor(id: string) {
-    super();
-    this.id = id;
-  }
-}