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

package/src/stores/LegendDataCubeDuckDBEngine.ts

@@ -18,6 +18,8 @@ import * as duckdb from '@duckdb/duckdb-wasm';
 import duckdb_wasm from '@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm';
 import duckdb_wasm_next from '@duckdb/duckdb-wasm/dist/duckdb-eh.wasm';
 import {
+  DATE_FORMAT,
+  DATE_TIME_FORMAT,
   INTERNAL__TDSColumn,
   PRIMITIVE_TYPE,
   TDSBuilder,
@@ -28,8 +30,11 @@ import {
 import {
   assertNonNullable,
   csvStringify,
+  formatDate,
   guaranteeNonNullable,
+  isNullable,
   UnsupportedOperationError,
+  uuid,
 } from '@finos/legend-shared';
 import type { CachedDataCubeSource } from '@finos/legend-data-cube';
 import { Type } from 'apache-arrow';
@@ -48,6 +53,7 @@ export class LegendDataCubeDuckDBEngine {
   // Options for creating csv using papa parser: https://www.papaparse.com/docs#config
   private static readonly ESCAPE_CHAR = `'`;
   private static readonly QUOTE_CHAR = `'`;
+  private _catalog: Map<string, DuckDBCatalogTable> = new Map();
 
   private _database?: duckdb.AsyncDuckDB | undefined;
 
@@ -58,6 +64,13 @@ export class LegendDataCubeDuckDBEngine {
     );
   }
 
+  retrieveCatalogTable(ref: string) {
+    return guaranteeNonNullable(
+      this._catalog.get(ref),
+      `Can't find reference ${ref}`,
+    );
+  }
+
   async initialize() {
     // Initialize DuckDB with WASM
     // See: https://duckdb.org/docs/api/wasm/instantiation.html
@@ -99,35 +112,90 @@ export class LegendDataCubeDuckDBEngine {
     const table = `${LegendDataCubeDuckDBEngine.CACHE_TABLE_NAME_PREFIX}${LegendDataCubeDuckDBEngine.cacheTableCounter}`;
     const csvFileName = `${LegendDataCubeDuckDBEngine.CACHE_FILE_NAME}${LegendDataCubeDuckDBEngine.cacheTableCounter}.csv`;
 
+    const columns: string[] = [];
     const columnNames: string[] = [];
-    result.builder.columns.forEach((col) => columnNames.push(col.name));
+    result.builder.columns.forEach((col) => {
+      let colType: string;
+      switch (col.type as string) {
+        case PRIMITIVE_TYPE.BINARY: {
+          colType = 'BIT';
+          break;
+        }
+        case PRIMITIVE_TYPE.BOOLEAN: {
+          colType = 'BOOLEAN';
+          break;
+        }
+        case PRIMITIVE_TYPE.NUMBER: {
+          colType = 'DOUBLE';
+          break;
+        }
+        case PRIMITIVE_TYPE.INTEGER: {
+          colType = 'INTEGER';
+          break;
+        }
+        // TODO: we need precision and scale
+        case PRIMITIVE_TYPE.DECIMAL: {
+          colType = 'DECIMAL';
+          break;
+        }
+        case PRIMITIVE_TYPE.FLOAT: {
+          colType = 'FLOAT';
+          break;
+        }
+        case PRIMITIVE_TYPE.STRICTDATE:
+        case PRIMITIVE_TYPE.DATE: {
+          colType = 'DATE';
+          break;
+        }
+        case PRIMITIVE_TYPE.DATETIME: {
+          colType = 'TIMESTAMP';
+          break;
+        }
+        case PRIMITIVE_TYPE.STRING: {
+          colType = 'VARCHAR';
+          break;
+        }
+        default: {
+          throw new UnsupportedOperationError(
+            `Can't initialize cache: failed to find matching DuckDB type for Pure type '${col.type}'`,
+          );
+        }
+      }
+      columns.push(`"${col.name}" ${colType}`);
+      columnNames.push(col.name);
+    });
 
     const data = result.result.rows.map((row) => row.values);
 
-    const csvContent = csvStringify([columnNames, ...data], {
-      escapeChar: LegendDataCubeDuckDBEngine.ESCAPE_CHAR,
-      quoteChar: LegendDataCubeDuckDBEngine.QUOTE_CHAR,
-    });
+    const csvContent = csvStringify([columnNames, ...data]);
     await this.database.registerFileText(csvFileName, csvContent);
 
     const connection = await this.database.connect();
+
+    // we create our own table schema becuase of date type conversions from arrow to duckDB data types
+    const CREATE_TABLE_SQL = `CREATE TABLE ${schema}.${table} (${columns.join(',')})`;
+    await connection.query(CREATE_TABLE_SQL);
+
     await connection.insertCSVFromPath(csvFileName, {
       schema: schema,
       name: table,
-      create: true,
-      header: true,
+      create: false,
+      header: true, // we add header and get it to autodetect otherwise we would have to provide column details with arrow datatypes
       detect: true,
-      dateFormat: 'YYYY-MM-DD',
-      timestampFormat: 'YYYY-MM-DD', // make sure Date is not auto-converted to timestamp
-      escape: LegendDataCubeDuckDBEngine.ESCAPE_CHAR,
-      quote: LegendDataCubeDuckDBEngine.QUOTE_CHAR,
     });
     await connection.close();
 
     return { schema, table, rowCount: result.result.rows.length };
   }
 
-  async ingestLocalFileData(data: string, format: string) {
+  async ingestLocalFileData(data: string, format: string, refId?: string) {
+    if (!isNullable(refId) && this._catalog.has(refId)) {
+      const dbDetails = guaranteeNonNullable(this._catalog.get(refId));
+      return {
+        dbReference: refId,
+        columnNames: dbDetails.columns.map((col) => col[0] as string),
+      };
+    }
     const schema = LegendDataCubeDuckDBEngine.DUCKDB_DEFAULT_SCHEMA_NAME;
     LegendDataCubeDuckDBEngine.ingestFileTableCounter += 1;
     const table = `${LegendDataCubeDuckDBEngine.INGEST_TABLE_NAME_PREFIX}${LegendDataCubeDuckDBEngine.ingestFileTableCounter}`;
@@ -144,8 +212,6 @@ export class LegendDataCubeDuckDBEngine {
           name: table,
           header: true,
           detect: true,
-          dateFormat: 'YYYY-MM-DD',
-          timestampFormat: 'YYYY-MM-DD', // make sure Date is not auto-converted to timestamp
           escape: LegendDataCubeDuckDBEngine.ESCAPE_CHAR,
           quote: LegendDataCubeDuckDBEngine.QUOTE_CHAR,
         });
@@ -161,12 +227,22 @@ export class LegendDataCubeDuckDBEngine {
     const tableSpec = (await connection.query(`DESCRIBE ${schema}.${table}`))
       .toArray()
       .map((spec) => [
-        spec[LegendDataCubeDuckDBEngine.COLUMN_NAME],
-        spec[LegendDataCubeDuckDBEngine.COLUMN_TYPE],
+        spec[LegendDataCubeDuckDBEngine.COLUMN_NAME] as string,
+        spec[LegendDataCubeDuckDBEngine.COLUMN_TYPE] as string,
       ]);
     await connection.close();
 
-    return { schema, table, tableSpec };
+    const ref = isNullable(refId) ? uuid() : refId;
+    this._catalog.set(ref, {
+      schemaName: schema,
+      tableName: table,
+      columns: tableSpec,
+    } satisfies DuckDBCatalogTable);
+
+    return {
+      dbReference: ref,
+      columnNames: tableSpec.map((spec) => spec[0] as string),
+    };
   }
 
   async runSQLQuery(sql: string) {
@@ -176,16 +252,21 @@ export class LegendDataCubeDuckDBEngine {
 
     const data = result.toArray();
     const columnNames = result.schema.fields.map((field) => field.name);
+    const columnTypesIds = result.schema.fields.map((field) => field.typeId);
     const rows = data.map((row) => {
       const tdsRow = new TDSRow();
-      tdsRow.values = columnNames.map((column) => {
+      tdsRow.values = columnNames.map((column, idx) => {
         const value = row[column] as unknown;
         // NOTE: DuckDB WASM returns ArrayBuffer for numeric value, such as for count(*)
         // so we need to convert it to number
         if (ArrayBuffer.isView(value)) {
           return row[column].valueOf() as number;
-          // BigInt is not supported by ag-grid, so we need to convert it to native number
+        } else if (columnTypesIds[idx] === Type.Date) {
+          return formatDate(new Date(Number(value)), DATE_FORMAT);
+        } else if (columnTypesIds[idx] === Type.Timestamp) {
+          return formatDate(new Date(Number(value)), DATE_TIME_FORMAT);
         } else if (typeof value === 'bigint') {
+          // BigInt is not supported by ag-grid, so we need to convert it to native number
           return Number(value);
         }
         return value as string | number | boolean | null;
@@ -210,13 +291,16 @@ export class LegendDataCubeDuckDBEngine {
           col.type = PRIMITIVE_TYPE.BOOLEAN;
           break;
         }
-        case Type.Timestamp:
         case Type.Date:
         case Type.DateDay:
         case Type.DateMillisecond: {
           col.type = PRIMITIVE_TYPE.DATE;
           break;
         }
+        case Type.Timestamp: {
+          col.type = PRIMITIVE_TYPE.DATETIME;
+          break;
+        }
         case Type.Utf8:
         case Type.LargeUtf8: {
           col.type = PRIMITIVE_TYPE.STRING;
@@ -269,3 +353,9 @@ export class LegendDataCubeDuckDBEngine {
     await this._database?.terminate();
   }
 }
+
+type DuckDBCatalogTable = {
+  schemaName: string;
+  tableName: string;
+  columns: string[][];
+};

package/src/stores/builder/LegendDataCubeBuilderStore.tsx

@@ -42,6 +42,8 @@ import {
   assertErrorThrown,
   formatDate,
   isString,
+  returnUndefOnError,
+  UnsupportedOperationError,
   uuid,
 } from '@finos/legend-shared';
 import type { LegendDataCubeDataCubeEngine } from '../LegendDataCubeDataCubeEngine.js';
@@ -58,8 +60,14 @@ import {
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import { LegendDataCubeBlockingWindowState } from '../../components/LegendDataCubeBlockingWindow.js';
 import { LegendDataCubeDeleteConfirmation } from '../../components/builder/LegendDataCubeDeleteConfirmation.js';
-import { LegendDataCubeAbout } from '../../components/builder/LegendDataCubeBuilder.js';
+import {
+  LegendDataCubeAbout,
+  LegendDataCubeReleaseLogManager,
+} from '../../components/builder/LegendDataCubeBuilder.js';
 import { LegendDataCubeSourceViewer } from '../../components/builder/LegendDataCubeSourceViewer.js';
+import { LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE } from '../model/LocalFileDataCubeSource.js';
+import type { LegendDataCubeSourceLoaderState } from './source/LegendDataCubeSourceLoaderState.js';
+import { LocalFileDataCubeSourceLoaderState } from './source/LocalFileDataCubeSourceLoaderState.js';
 
 export class LegendDataCubeBuilderState {
   readonly uuid = uuid();
@@ -121,6 +129,8 @@ export class LegendDataCubeBuilderStore {
 
   readonly initializeState = ActionState.create();
   readonly aboutDisplay: DisplayState;
+  readonly releaseLogDisplay: DisplayState;
+  readonly releaseNotesDisplay: DisplayState;
 
   readonly creator: LegendDataCubeCreatorState;
 
@@ -136,6 +146,8 @@ export class LegendDataCubeBuilderStore {
   builder?: LegendDataCubeBuilderState | undefined;
   readonly sourceViewerDisplay: DisplayState;
 
+  sourceLoader?: LegendDataCubeSourceLoaderState | undefined;
+
   private passedFirstLoad = false;
 
   constructor(baseStore: LegendDataCubeBaseStore) {
@@ -143,6 +155,9 @@ export class LegendDataCubeBuilderStore {
       builder: observable,
       setBuilder: action,
 
+      sourceLoader: observable,
+      setSourceLoader: action,
+
       dataCubeToDelete: observable,
       setDataCubeToDelete: action,
     });
@@ -169,6 +184,23 @@ export class LegendDataCubeBuilderStore {
       },
     );
 
+    this.releaseLogDisplay = this.layoutService.newDisplay(
+      'Release Log',
+      () => <LegendDataCubeReleaseLogManager showOnlyLatestNotes={false} />,
+      {
+        ...DEFAULT_ALERT_WINDOW_CONFIG,
+        height: 500,
+      },
+    );
+    this.releaseNotesDisplay = this.layoutService.newDisplay(
+      'Release Notes',
+      () => <LegendDataCubeReleaseLogManager showOnlyLatestNotes={true} />,
+      {
+        ...DEFAULT_ALERT_WINDOW_CONFIG,
+        height: 350,
+      },
+    );
+
     this.creator = new LegendDataCubeCreatorState(this);
     this.loader = new LegendDataCubeLoaderState(this);
     this.saverDisplay = new LegendDataCubeBlockingWindowState(
@@ -201,6 +233,10 @@ export class LegendDataCubeBuilderStore {
     this.builder = val;
   }
 
+  setSourceLoader(val: LegendDataCubeSourceLoaderState | undefined) {
+    this.sourceLoader = val;
+  }
+
   private updateWindowTitle(persistentDataCube: PersistentDataCube) {
     this.application.layoutService.setWindowTitle(
       `\u229E ${persistentDataCube.name}${this.builder ? ` - ${formatDate(new Date(this.builder.startTime), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
@@ -253,6 +289,44 @@ export class LegendDataCubeBuilderStore {
     }
   }
 
+  private getSourceLoader(
+    specification: DataCubeSpecification,
+    persistentDataCube: PersistentDataCube,
+  ) {
+    const sourceData = specification.source;
+    const onSuccess = async () => {
+      const dataCubeId = persistentDataCube.id;
+      this.finalizeLoad(specification, persistentDataCube, dataCubeId);
+      this.loadState.pass();
+    };
+    const onError = async (error: unknown) => {
+      assertErrorThrown(error);
+      this.alertService.alertError(error, {
+        message: `DataCube Load Failure: ${error.message}`,
+      });
+      this.application.navigationService.navigator.updateCurrentLocation(
+        generateBuilderRoute(null),
+      );
+      this.loadState.fail();
+    };
+    switch (sourceData._type) {
+      case LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE:
+        return new LocalFileDataCubeSourceLoaderState(
+          this.application,
+          this.engine,
+          this.alertService,
+          sourceData,
+          persistentDataCube,
+          onSuccess,
+          onError,
+        );
+      default:
+        throw new UnsupportedOperationError(
+          `Can't create source loader for unsupported type '${sourceData._type}'`,
+        );
+    }
+  }
+
   async loadDataCube(dataCubeId: string | undefined) {
     // internalize the parameters and clean them from the URL
     const sourceData =
@@ -295,32 +369,17 @@ export class LegendDataCubeBuilderStore {
         const specification = DataCubeSpecification.serialization.fromJson(
           persistentDataCube.content,
         );
-        this.setBuilder(
-          new LegendDataCubeBuilderState(specification, persistentDataCube),
-        );
-        this.updateWindowTitle(persistentDataCube);
 
-        // update the list of stack of recently viewed DataCubes
-        const recentlyViewedDataCubes = this.getRecentlyViewedDataCubes();
-        const idx = recentlyViewedDataCubes.findIndex(
-          (data) => data === dataCubeId,
+        const sourceLoader = returnUndefOnError(() =>
+          this.getSourceLoader(specification, persistentDataCube),
         );
-        if (idx === -1) {
-          if (
-            recentlyViewedDataCubes.length >= RECENTLY_VIEWED_DATA_CUBES_LIMIT
-          ) {
-            recentlyViewedDataCubes.pop();
-          }
-          recentlyViewedDataCubes.unshift(dataCubeId);
-        } else {
-          recentlyViewedDataCubes.splice(idx, 1);
-          recentlyViewedDataCubes.unshift(dataCubeId);
+        if (sourceLoader !== undefined) {
+          this.setSourceLoader(sourceLoader);
+          sourceLoader.display.open();
+          return;
         }
-        this.application.userDataService.persistValue(
-          LegendDataCubeUserDataKey.RECENTLY_VIEWED_DATA_CUBES,
-          recentlyViewedDataCubes,
-        );
 
+        this.finalizeLoad(specification, persistentDataCube, dataCubeId);
         this.loadState.pass();
       } catch (error) {
         assertErrorThrown(error);
@@ -336,6 +395,36 @@ export class LegendDataCubeBuilderStore {
     }
   }
 
+  private finalizeLoad(
+    specification: DataCubeSpecification,
+    persistentDataCube: PersistentDataCube,
+    dataCubeId: string,
+  ) {
+    this.setBuilder(
+      new LegendDataCubeBuilderState(specification, persistentDataCube),
+    );
+    this.updateWindowTitle(persistentDataCube);
+
+    // update the list of stack of recently viewed DataCubes
+    const recentlyViewedDataCubes = this.getRecentlyViewedDataCubes();
+    const idx = recentlyViewedDataCubes.findIndex(
+      (data) => data === dataCubeId,
+    );
+    if (idx === -1) {
+      if (recentlyViewedDataCubes.length >= RECENTLY_VIEWED_DATA_CUBES_LIMIT) {
+        recentlyViewedDataCubes.pop();
+      }
+      recentlyViewedDataCubes.unshift(dataCubeId);
+    } else {
+      recentlyViewedDataCubes.splice(idx, 1);
+      recentlyViewedDataCubes.unshift(dataCubeId);
+    }
+    this.application.userDataService.persistValue(
+      LegendDataCubeUserDataKey.RECENTLY_VIEWED_DATA_CUBES,
+      recentlyViewedDataCubes,
+    );
+  }
+
   private async generatePersistentDataCube(
     api: DataCubeAPI,
     name: string,
@@ -391,6 +480,7 @@ export class LegendDataCubeBuilderStore {
       // Another way to avoid reloading the whole app it to force update
       // the <DataCube/> component using the key prop that ties to an ID
       // of the builder.
+      this.builder.setPersistentDataCube(newPersistentDataCube);
       this.application.navigationService.navigator.updateCurrentLocation(
         generateBuilderRoute(newPersistentDataCube.id),
       );
@@ -439,6 +529,7 @@ export class LegendDataCubeBuilderStore {
         // Another way to avoid reloading the whole app it to force update
         // the <DataCube/> component using the key prop that ties to an ID
         // of the builder.
+        this.builder.setPersistentDataCube(newPersistentDataCube);
         this.application.navigationService.navigator.updateCurrentLocation(
           generateBuilderRoute(newPersistentDataCube.id),
         );

package/src/stores/builder/source/LegendDataCubeSourceLoaderState.tsx

@@ -0,0 +1,104 @@
+/**
+ * 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,
+  assertErrorThrown,
+  type PlainObject,
+} from '@finos/legend-shared';
+import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseStore.js';
+import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
+import {
+  DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
+  type DataCubeAlertService,
+} from '@finos/legend-data-cube';
+import { LegendDataCubeBlockingWindowState } from '../../../components/LegendDataCubeBlockingWindow.js';
+import { generateBuilderRoute } from '../../../__lib__/LegendDataCubeNavigation.js';
+import { LegendDataCubeSourceLoader } from '../../../components/builder/source/LegendDataCubeSourceLoader.js';
+import type { PersistentDataCube } from '@finos/legend-graph';
+
+export abstract class LegendDataCubeSourceLoaderState {
+  protected readonly _application: LegendDataCubeApplicationStore;
+  protected readonly _engine: LegendDataCubeDataCubeEngine;
+  protected readonly _alertService: DataCubeAlertService;
+
+  readonly display: LegendDataCubeBlockingWindowState;
+  readonly finalizeState = ActionState.create();
+
+  protected readonly onSuccess: () => Promise<void>;
+  protected readonly onError: (error: unknown) => Promise<void>;
+  readonly sourceData: PlainObject;
+  readonly persistentDataCube: PersistentDataCube;
+
+  constructor(
+    application: LegendDataCubeApplicationStore,
+    engine: LegendDataCubeDataCubeEngine,
+    alertService: DataCubeAlertService,
+    sourceData: PlainObject,
+    persistentDataCube: PersistentDataCube,
+    onSuccess: () => Promise<void>,
+    onError: (error: unknown) => Promise<void>,
+  ) {
+    this._application = application;
+    this._engine = engine;
+    this._alertService = alertService;
+
+    this.sourceData = sourceData;
+    this.persistentDataCube = persistentDataCube;
+    this.onSuccess = onSuccess;
+    this.onError = onError;
+
+    this.display = new LegendDataCubeBlockingWindowState(
+      'Load DataCube',
+      () => <LegendDataCubeSourceLoader state={this} />,
+      {
+        ...DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
+        width: 500,
+        minWidth: 500,
+      },
+      () => {
+        this._application.navigationService.navigator.updateCurrentLocation(
+          generateBuilderRoute(null),
+        );
+      },
+    );
+  }
+
+  abstract initialize(): void;
+
+  abstract get label(): string;
+
+  abstract get isValid(): boolean;
+
+  abstract load(source: PlainObject | undefined): Promise<PlainObject>;
+
+  async finalize() {
+    this.finalizeState.inProgress();
+    try {
+      await this.load(this.sourceData);
+      this.display.close();
+      await this.onSuccess();
+      this.finalizeState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this._alertService.alertError(error, {
+        message: `DataCube Load Failure: ${error.message}`,
+      });
+      await this.onError(error);
+      this.finalizeState.fail();
+    }
+  }
+}

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

@@ -17,7 +17,7 @@
 import {
   ActionState,
   csvStringify,
-  guaranteeType,
+  guaranteeNonNullable,
   IllegalStateError,
   parseCSVFile,
   type PlainObject,
@@ -30,7 +30,6 @@ import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseSto
 import { action, makeObservable, observable } from 'mobx';
 import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
 import {
-  LocalFileDataCubeSource,
   LocalFileDataCubeSourceFormat,
   RawLocalFileQueryDataCubeSource,
 } from '../../model/LocalFileDataCubeSource.js';
@@ -39,7 +38,7 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
   readonly processState = ActionState.create();
 
   fileName?: string | undefined;
-  fileFormat?: string | undefined;
+  fileFormat?: LocalFileDataCubeSourceFormat | undefined;
   // NOTE: type string is suitable for CSV/Excel, etc. but will not be appropriate
   // for other format that we want to support, e.g. arrow/parquet
   fileData?: string | undefined;
@@ -74,7 +73,7 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
     this.fileName = fileName;
   }
 
-  setFileFormat(format: string | undefined) {
+  setFileFormat(format: LocalFileDataCubeSourceFormat | undefined) {
     this.fileFormat = format;
   }
 
@@ -114,7 +113,7 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
               csvStringify(result.data, { escapeChar: `'`, quoteChar: `'` }),
             );
             this.setFileName(fileName);
-            this.setFileFormat(fileFormat);
+            this.setFileFormat(LocalFileDataCubeSourceFormat.CSV);
             this.setRowCount(result.data.length);
             this.setPreviewText(
               csvStringify(result.data.slice(0, 100), {
@@ -160,19 +159,15 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
       );
     }
 
-    const source = guaranteeType(
+    const tableDetails = guaranteeNonNullable(
       await this._engine.ingestLocalFileData(this.fileData, this.fileFormat),
-      LocalFileDataCubeSource,
-      `Can't generate data source`,
+      `Can't generate source data: failed to ingest data from local file`,
     );
     const rawSource = new RawLocalFileQueryDataCubeSource();
-    rawSource.count = this.rowCount;
     rawSource.fileName = this.fileName;
-    rawSource.db = source.db;
-    rawSource.model = source.model;
-    rawSource.schema = source.schema;
-    rawSource.table = source.table;
-    rawSource.runtime = source.runtime;
+    rawSource.fileFormat = this.fileFormat;
+    rawSource._ref = tableDetails.dbReference;
+    rawSource.columnNames = tableDetails.columnNames;
 
     return RawLocalFileQueryDataCubeSource.serialization.toJson(rawSource);
   }