@finos/legend-cube-builder 0.0.4 → 0.0.6

package/src/stores/source-picker/CubeDirectConnectionTabState.ts

@@ -20,6 +20,7 @@ import {
   type ModelContext,
   RELATIONAL_TABLE_SOURCE_DEFINITION,
   RelationalTableSource,
+  Schema,
 } from '@finos/legend-cube';
 import { assertErrorThrown, type GeneratorFn } from '@finos/legend-shared';
 import {
@@ -63,6 +64,8 @@ import {
 import {
   type CubeSourcePickerTab,
   CubeSourcePickerTabKey,
+  CUBE_TABLE_PREVIEW_DELAY_MS,
+  generateCubeNodeIds,
 } from './CubeSourcePickerTab.js';
 
 /** An error as the tab shows it: its first line, with the rest on demand (R48) */
@@ -147,11 +150,19 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
   /** The schema's tables; none until they are listed */
   schemaTables: readonly CubeExploredTable[] | undefined;
   /** The picked table, by its stored (quoted) name */
-  tableName: string | undefined;
+  /** The picked tables' stored names, in the order picked; several are added at once */
+  tableNames: readonly string[] = [];
   tableSearch = '';
   isTesting = false;
   isListing = false;
   isResolving = false;
+  /** The table, by its stored name, whose columns the tab shows under the list: the one picked last */
+  previewTableName: string | undefined;
+  /** The columns of each table previewed, or why they couldn't be read, by schema and stored name */
+  previewSchemas: ReadonlyMap<string, Schema | string> = new Map();
+  /** Counts the connection's changes, so a late preview is dropped */
+  private previewGeneration = 0;
+  private previewTimer: ReturnType<typeof setTimeout> | undefined;
   error: CubeDirectConnectionError | undefined;
   /** DuckDB only: a CSV to add to the setup SQL as a table, pasted or read from a file */
   csvText = '';
@@ -176,11 +187,16 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
       schemas: observable.ref,
       schemaName: observable,
       schemaTables: observable.ref,
-      tableName: observable,
+      tableNames: observable.ref,
+      tableName: computed,
       tableSearch: observable,
       isTesting: observable,
       isListing: observable,
       isResolving: observable,
+      previewTableName: observable,
+      previewSchemas: observable.ref,
+      previewedColumns: computed,
+      loadPreview: flow,
       error: observable.ref,
       csvText: observable,
       csvTableName: observable,
@@ -203,6 +219,7 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
       setDuckDbPath: action,
       selectSchema: action,
       selectTable: action,
+      toggleTable: action,
       setTableSearch: action,
       setCsvText: action,
       setCsvTableName: action,
@@ -303,9 +320,20 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     );
   }
 
+  /** The one picked table's stored name; none when several are */
+  get tableName(): string | undefined {
+    return this.tableNames.length === 1 ? this.tableNames[0] : undefined;
+  }
+
+  /** How many tables Add adds */
+  get pickedCount(): number {
+    return this.tableNames.length;
+  }
+
   get canConfirm(): boolean {
-    const table = this.schemaTables?.find(
-      (candidate) => candidate.storedName === this.tableName,
+    // a picked table hidden by the search still counts
+    const tables = this.tableNames.map((name) =>
+      this.schemaTables?.find((candidate) => candidate.storedName === name),
     );
     return (
       this.isOffered &&
@@ -315,8 +343,10 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
       this.connection !== undefined &&
       this.connection === this.testedConnection &&
       this.schemaName !== undefined &&
-      table !== undefined &&
-      isExploredTableSelectable(table)
+      tables.length > 0 &&
+      tables.every(
+        (table) => table !== undefined && isExploredTableSelectable(table),
+      )
     );
   }
 
@@ -434,9 +464,101 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     }
   }
 
+  /** Picks the table alone, in place of any picked, and previews its columns */
   selectTable(storedName: string | undefined): void {
-    this.tableName = storedName;
+    this.tableNames = storedName === undefined ? [] : [storedName];
+    this.error = undefined;
+    this.preview(storedName);
+  }
+
+  /** Adds the table to the picked ones, previewing it, or takes it out */
+  toggleTable(storedName: string): void {
+    const adding = !this.tableNames.includes(storedName);
+    this.tableNames = adding
+      ? [...this.tableNames, storedName]
+      : this.tableNames.filter((each) => each !== storedName);
     this.error = undefined;
+    this.preview(adding ? storedName : this.tableNames.at(-1));
+  }
+
+  private previewKey(storedName: string): string {
+    return `${this.schemaName ?? ''}\u0000${storedName}`;
+  }
+
+  /** The previewed table's columns, `undefined` while they load, or why they couldn't be read */
+  get previewedColumns(): Schema | string | undefined {
+    const name = this.previewTableName;
+    return name === undefined
+      ? undefined
+      : this.previewSchemas.get(this.previewKey(name));
+  }
+
+  /** Previews the table once the clicks pause (`CUBE_TABLE_PREVIEW_DELAY_MS`) */
+  private preview(storedName: string | undefined): void {
+    this.previewTableName = storedName;
+    this.cancelPreview();
+    if (storedName !== undefined) {
+      this.previewTimer = setTimeout(() => {
+        this.previewTimer = undefined;
+        flowResult(this.loadPreview(storedName)).catch(
+          this.editorState.host.applicationStore.alertUnhandledError,
+        );
+      }, CUBE_TABLE_PREVIEW_DELAY_MS);
+    }
+  }
+
+  private cancelPreview(): void {
+    if (this.previewTimer !== undefined) {
+      clearTimeout(this.previewTimer);
+      this.previewTimer = undefined;
+    }
+  }
+
+  /** Reads a table's columns from the engine, over the connection tested */
+  *loadPreview(storedName: string): GeneratorFn<void> {
+    const key = this.previewKey(storedName);
+    const table = this.schemaTables?.find(
+      (candidate) => candidate.storedName === storedName,
+    );
+    const connection = this.testedConnection;
+    const schemaName = this.schemaName;
+    if (
+      this.previewSchemas.has(key) ||
+      !table ||
+      !connection ||
+      schemaName === undefined
+    ) {
+      return;
+    }
+    const model =
+      this.editorState.document.context?.model ??
+      createCubeDirectModel(connection);
+    const coordinates = getCubeDirectTableCoordinates(schemaName, table);
+    const generation = this.previewGeneration;
+    const id = this.editorState.document.query.generateId(
+      RelationalTableSource.TYPE,
+    );
+    let answer: Schema | string;
+    try {
+      const typed = (yield this.editorState.host.engine.resolveSchemas(
+        model,
+        new Map([
+          [id, [coordinates.database, coordinates.schema, coordinates.table]],
+        ]),
+      )) as Awaited<
+        ReturnType<typeof this.editorState.host.engine.resolveSchemas>
+      >;
+      const schema = typed.get(id);
+      answer =
+        schema instanceof Schema
+          ? schema
+          : (schema?.message ?? CUBE_DIRECT_MESSAGE.NO_TABLE_SCHEMA);
+    } catch (error) {
+      answer = toError(error).message;
+    }
+    if (generation === this.previewGeneration) {
+      this.previewSchemas = new Map(this.previewSchemas).set(key, answer);
+    }
   }
 
   setTableSearch(search: string): void {
@@ -476,6 +598,7 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     this.isTesting = false;
     this.isListing = false;
     this.isResolving = false;
+    this.cancelPreview();
   }
 
   /** Lists the connection's schemas; with a single one, lists its tables */
@@ -558,58 +681,130 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     const model: ModelContext =
       contextBefore?.model ??
       createCubeDirectModel(this.connection as CubeDirectConnection);
-    const table = this.schemaTables?.find(
-      (candidate) => candidate.storedName === this.tableName,
-    ) as CubeExploredTable;
-    const coordinates = getCubeDirectTableCoordinates(
-      this.schemaName as string,
-      table,
+    const tables = this.tableNames.map(
+      (name) =>
+        this.schemaTables?.find(
+          (candidate) => candidate.storedName === name,
+        ) as CubeExploredTable,
     );
-    // the engine stamps the table's accessor with its node id, so the id comes first
-    const id = editorState.document.query.generateId(
+    const schemaName = this.schemaName as string;
+    // the engine stamps each table's accessor with its node id, so the ids come first
+    const ids = generateCubeNodeIds(
+      editorState.document.query,
       RelationalTableSource.TYPE,
+      tables.length,
     );
+    this.cancelPreview();
     const request = ++this.confirmRequest;
     this.isResolving = true;
     this.error = undefined;
     try {
-      const typed = (yield editorState.host.engine.resolveSchemas(
-        model,
-        new Map([
-          [id, [coordinates.database, coordinates.schema, coordinates.table]],
-        ]),
-      )) as Awaited<ReturnType<typeof editorState.host.engine.resolveSchemas>>;
+      // a table previewed has its columns already: the engine types the others
+      const typed = new Map<string, Schema | CubeEngineError>();
+      const toType = new Map<string, readonly [string, string, string]>();
+      tables.forEach((table, index) => {
+        const id = ids[index] as string;
+        const schema = this.previewSchemas.get(
+          this.previewKey(table.storedName),
+        );
+        if (schema instanceof Schema) {
+          typed.set(id, schema);
+        } else {
+          const coordinates = getCubeDirectTableCoordinates(schemaName, table);
+          toType.set(id, [
+            coordinates.database,
+            coordinates.schema,
+            coordinates.table,
+          ]);
+        }
+      });
+      if (toType.size) {
+        const answer = (yield editorState.host.engine.resolveSchemas(
+          model,
+          toType,
+        )) as Awaited<
+          ReturnType<typeof editorState.host.engine.resolveSchemas>
+        >;
+        answer.forEach((schema, id) => typed.set(id, schema));
+      }
       if (request !== this.confirmRequest) {
         return false;
       }
-      const schema = typed.get(id);
-      if (schema === undefined || schema instanceof CubeEngineError) {
-        throw (
-          schema ??
-          new CubeEngineError(
-            CubeEngineErrorKind.COMPILE,
-            CUBE_DIRECT_MESSAGE.NO_TABLE_SCHEMA,
-          )
-        );
-      }
-      const node = RELATIONAL_TABLE_SOURCE_DEFINITION.resolve(
-        RELATIONAL_TABLE_SOURCE_DEFINITION.fromCoordinates(id, coordinates),
-        { kind: 'resolved', schema },
-      );
       const { document } = editorState;
-      if (document.context !== contextBefore || !document.query.canAdd(node)) {
+      if (document.context !== contextBefore) {
         throw new Error(CUBE_DIRECT_MESSAGE.CUBE_CHANGED);
       }
-      const query = document.query.add(node);
-      editorState.applyDocument(
-        document.context
-          ? document.withQuery(query)
-          : document
-              .withContext({ model, runtime: CUBE_DIRECT_RUNTIME_PATH })
-              .withQuery(query),
-      );
-      // what was tested is now the cube's connection
-      this.testedConnection = this.connection;
+      // each table typed is added, in the order picked; the first one picked
+      // is the one that runs on an empty cube, as a single table would be
+      let query = document.query;
+      const added: string[] = [];
+      const failed: CubeDirectConnectionError[] = [];
+      // with several tables, each failure names its table
+      const named = (
+        table: CubeExploredTable,
+        error: CubeDirectConnectionError,
+      ): CubeDirectConnectionError =>
+        tables.length > 1
+          ? { ...error, message: `${table.name}: ${error.message}` }
+          : error;
+      tables.forEach((table, index) => {
+        const id = ids[index] as string;
+        const schema = typed.get(id);
+        if (schema === undefined || schema instanceof CubeEngineError) {
+          failed.push(
+            named(
+              table,
+              toError(
+                schema ??
+                  new CubeEngineError(
+                    CubeEngineErrorKind.COMPILE,
+                    CUBE_DIRECT_MESSAGE.NO_TABLE_SCHEMA,
+                  ),
+              ),
+            ),
+          );
+          return;
+        }
+        const node = RELATIONAL_TABLE_SOURCE_DEFINITION.resolve(
+          RELATIONAL_TABLE_SOURCE_DEFINITION.fromCoordinates(
+            id,
+            getCubeDirectTableCoordinates(schemaName, table),
+          ),
+          { kind: 'resolved', schema },
+        );
+        if (!query.canAdd(node)) {
+          failed.push(
+            named(table, { message: CUBE_DIRECT_MESSAGE.CUBE_CHANGED }),
+          );
+          return;
+        }
+        query = query.add(node);
+        added.push(table.storedName);
+      });
+      if (added.length) {
+        editorState.applyDocument(
+          document.context
+            ? document.withQuery(query)
+            : document
+                .withContext({ model, runtime: CUBE_DIRECT_RUNTIME_PATH })
+                .withQuery(query),
+        );
+        // what was tested is now the cube's connection
+        this.testedConnection = this.connection;
+      }
+      if (failed.length) {
+        // the tables added aren't picked any more, so Add again adds only the others
+        this.tableNames = this.tableNames.filter(
+          (name) => !added.includes(name),
+        );
+        this.error =
+          failed.length === 1
+            ? failed[0]
+            : {
+                message: failed.map((each) => each.message).join('\n'),
+              };
+        return false;
+      }
       this.resetTable();
       return true;
     } catch (error) {
@@ -626,6 +821,8 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
 
   /** Forgets what was read from the connection: it changed, or its answers are stale */
   private resetResults(): void {
+    this.previewGeneration++;
+    this.previewSchemas = new Map();
     this.testRequest++;
     this.listRequest++;
     this.confirmRequest++;
@@ -641,7 +838,9 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
   }
 
   private resetTable(): void {
-    this.tableName = undefined;
+    this.tableNames = [];
     this.tableSearch = '';
+    this.previewTableName = undefined;
+    this.cancelPreview();
   }
 }