@finos/legend-application-data-cube 0.1.0

package/src/stores/source/SavedDepotInputSourceState.ts

@@ -0,0 +1,103 @@
+/**
+ * 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,
+  guaranteeNonNullable,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { type CubeInputSource } from './CubeInputSource.js';
+import type { VersionedProjectData } from '@finos/legend-server-depot';
+import type { DataCubeEngine } from '@finos/legend-data-cube';
+import {
+  CubeInputSourceState,
+  DataCubeSourceType,
+} from './CubeInputSourceLoader.js';
+import type { LegendDataCubeStoreContext } from '../LegendDataCubeEditorStore.js';
+import { makeObservable, observable } from 'mobx';
+
+export enum SAVED_DEPOT_TYPE {
+  SERVICE = 'SERVICE',
+  FUNCTION = 'FUNCTION',
+  TABLE = 'TABLE',
+}
+
+export abstract class SavedDepotSourceState {
+  abstract get label(): SAVED_DEPOT_TYPE;
+}
+
+export class ServiceDepotSourceState extends SavedDepotSourceState {
+  override get label(): SAVED_DEPOT_TYPE {
+    return SAVED_DEPOT_TYPE.SERVICE;
+  }
+}
+
+export class SavedDepotInputSourceState extends CubeInputSourceState {
+  project: VersionedProjectData | undefined;
+  selectedSource: SavedDepotSourceState;
+
+  constructor(context: LegendDataCubeStoreContext) {
+    super(context);
+    makeObservable(this, {
+      project: observable,
+      selectedSource: observable,
+    });
+
+    this.selectedSource = this.build(guaranteeNonNullable(this.options[0]));
+  }
+
+  get options(): SAVED_DEPOT_TYPE[] {
+    return Object.values(SAVED_DEPOT_TYPE);
+  }
+  override process(): CubeInputSource {
+    // assertTrue(this.isValid);
+    // if (this.element instanceof Service) {
+    // }
+
+    throw new UnsupportedOperationError('');
+  }
+
+  *fectchAssociatedProjectsAndVersions(): GeneratorFn<void> {
+    throw new UnsupportedOperationError('not supported yet');
+  }
+
+  static override builder(
+    context: LegendDataCubeStoreContext,
+  ): CubeInputSourceState {
+    return new SavedDepotInputSourceState(context);
+  }
+
+  build(source: SAVED_DEPOT_TYPE): SavedDepotSourceState {
+    // if (source === SAVED_DEPOT_TYPE.SERVICE) {
+    // }
+
+    throw new UnsupportedOperationError('');
+  }
+
+  override get label(): DataCubeSourceType {
+    return DataCubeSourceType.DEPOT_QUERY;
+  }
+  override setup(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async buildCubeEngine(): Promise<DataCubeEngine | undefined> {
+    throw new Error('Method not implemented.');
+  }
+
+  override get isValid(): boolean {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/stores/source/SavedQueryInputSourceState.ts

@@ -0,0 +1,144 @@
+/**
+ * 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 {
+  assertTrue,
+  guaranteeNonNullable,
+  isNonNullable,
+} from '@finos/legend-shared';
+import {
+  LegendSavedQuerySource,
+  type CubeInputSource,
+} from './CubeInputSource.js';
+import {
+  CubeInputSourceState,
+  DataCubeSourceType,
+} from './CubeInputSourceLoader.js';
+import type { DataCubeEngine } from '@finos/legend-data-cube';
+import {
+  LegendSDLC,
+  QuerySearchSpecification,
+  type RawLambda,
+  type LightQuery,
+} from '@finos/legend-graph';
+import { resolveVersion } from '@finos/legend-server-depot';
+import { LegendExecutionDataCubeEngine } from '../engine/LegendExecutionDataCubeEngine.js';
+import type { LegendDataCubeStoreContext } from '../LegendDataCubeEditorStore.js';
+import {
+  QUERY_LOADER_TYPEAHEAD_SEARCH_LIMIT,
+  QueryLoaderState,
+} from '@finos/legend-query-builder';
+import { action, makeObservable, observable } from 'mobx';
+
+export class SavedQueryInputSourceState extends CubeInputSourceState {
+  query: LightQuery | undefined;
+  queryLoaderState: QueryLoaderState;
+
+  constructor(context: LegendDataCubeStoreContext) {
+    super(context);
+    makeObservable(this, {
+      query: observable,
+      buildCubeEngineState: observable,
+      setQuery: action,
+    });
+    this.queryLoaderState = new QueryLoaderState(
+      this.context.applicationStore,
+      this.context.graphManagerState,
+      {
+        loadQuery: (query: LightQuery): void => {
+          this.setQuery(query);
+        },
+        decorateSearchSpecification: (val) => val,
+        fetchDefaultQueries: async (): Promise<LightQuery[]> => {
+          const searchSpecification = new QuerySearchSpecification();
+          searchSpecification.limit = QUERY_LOADER_TYPEAHEAD_SEARCH_LIMIT;
+          return this.context.graphManagerState.graphManager.searchQueries(
+            QuerySearchSpecification.createDefault(undefined),
+          );
+        },
+        isReadOnly: true,
+      },
+    );
+  }
+
+  setQuery(query: LightQuery): void {
+    this.query = query;
+  }
+
+  override process(): CubeInputSource {
+    assertTrue(this.isValid);
+    return new LegendSavedQuerySource(guaranteeNonNullable(this.query).id);
+  }
+
+  override get openActionable(): boolean {
+    return false;
+  }
+
+  static override builder(
+    context: LegendDataCubeStoreContext,
+  ): CubeInputSourceState {
+    return new SavedQueryInputSourceState(context);
+  }
+  override get label(): DataCubeSourceType {
+    return DataCubeSourceType.LEGEND_QUERY;
+  }
+  override setup(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  async buildCubeEngine(): Promise<DataCubeEngine | undefined> {
+    this.buildCubeEngineState.inProgress();
+    const queryInfo =
+      await this.context.graphManagerState.graphManager.getQueryInfo(
+        guaranteeNonNullable(this.query).id,
+      );
+    const execConext =
+      (await this.context.graphManagerState.graphManager.resolveQueryInfoExecutionContext(
+        queryInfo,
+        () =>
+          this.context.depotServerClient.getVersionEntities(
+            queryInfo.groupId,
+            queryInfo.artifactId,
+            queryInfo.versionId,
+          ),
+      )) as { mapping: string | undefined; runtime: string };
+    const lambda =
+      (await 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.buildCubeEngineState.complete();
+    return engine;
+  }
+
+  override get isValid(): boolean {
+    return isNonNullable(this.query);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,82 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "webworker",
+      "scripthost"
+    ],
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "nodenext",
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./lib",
+    "tsBuildInfoFile": "./build/prod.tsbuildinfo",
+    "rootDir": "./src",
+    "jsx": "react-jsx",
+    "moduleResolution": "nodenext",
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "preserveConstEnums": true,
+    "incremental": true,
+    "useDefineForClassFields": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "strictBuiltinIteratorReturn": true,
+    "alwaysStrict": true,
+    "useUnknownInCatchVariables": true
+  },
+  "references": [
+    {
+      "path": "./tsconfig.package.json"
+    }
+  ],
+  "files": [
+    "./src/index.ts",
+    "./src/application/Core_LegendDataCubeApplicationPlugin.ts",
+    "./src/application/Core_LegendDataCube_LegendApplicationPlugin.ts",
+    "./src/application/LegendDataCubeApplicationConfig.ts",
+    "./src/application/LegendDataCubeApplicationPlugin.ts",
+    "./src/application/LegendDataCubePluginManager.ts",
+    "./src/stores/LegendDataCubeEditorStore.ts",
+    "./src/stores/engine/LegendExecutionDataCubeEngine.ts",
+    "./src/stores/source/CubeInputSource.ts",
+    "./src/stores/source/CubeInputSourceLoader.ts",
+    "./src/stores/source/LegendCubeViewer.ts",
+    "./src/stores/source/LegendDataCubeSourceBuilder.ts",
+    "./src/stores/source/SavedDepotInputSourceState.ts",
+    "./src/stores/source/SavedQueryInputSourceState.ts",
+    "./src/application/LegendDataCube.tsx",
+    "./src/components/DataCubeEditor.tsx",
+    "./src/components/LegendDataCubeFrameworkProvider.tsx",
+    "./src/components/LegendDataCubeWebApplication.tsx",
+    "./src/components/source/DataCubeSourceEditor.tsx",
+    "./src/components/source/SavedQuerySourceEditor.tsx"
+  ],
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.json"
+  ],
+  "exclude": [
+    "src/**/__tests__/**/*.*",
+    "src/**/__mocks__/**/*.*"
+  ]
+}

package/tsconfig.package.json

@@ -0,0 +1,54 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "webworker",
+      "scripthost"
+    ],
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "nodenext",
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./lib",
+    "tsBuildInfoFile": "./build/package.tsbuildinfo",
+    "rootDir": "./",
+    "moduleResolution": "nodenext",
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "preserveConstEnums": true,
+    "incremental": true,
+    "useDefineForClassFields": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "strictBuiltinIteratorReturn": true,
+    "alwaysStrict": true,
+    "useUnknownInCatchVariables": true
+  },
+  "files": [
+    "./package.json"
+  ],
+  "include": [
+    "package.json"
+  ],
+  "exclude": [
+    "/home/runner/work/legend-studio/legend-studio/packages/legend-application-data-cube/lib"
+  ]
+}