Method importDatabase

ui/src/store/ladybugStore.ts:1714–1979

(
    data: Uint8Array,
    onProgress?: (msg: string) => void,
  )

  }

  async importDatabase(
    data: Uint8Array,
    onProgress?: (msg: string) => void,
  ): Promise<ImportBatchResponse> {
    await this.ensureReady();

    // Unzip the Parquet archive and COPY FROM each file into the in-memory DB.
    onProgress?.('Unpacking Parquet archive');
    let entries: Record<string, Uint8Array>;
    try {
      entries = unzipSync(data);
    } catch (err) {
      throw new Error(
        `Failed to unzip archive. Make sure the file is a .parquet.zip exported from OpenTrace. (${err})`,
      );
    }

    const fileNames = Object.keys(entries);
    console.log(
      `[LadybugStore] importDatabase: archive contains ${fileNames.length} files:`,
      fileNames,
    );

    if (fileNames.length === 0) {
      throw new Error(
        'Archive contains no files. Make sure you are importing a .parquet.zip exported from OpenTrace.',
      );
    }

    // Clear current data and reset caches (also drains pending buffered writes)
    await this.clearGraph();

    let totalNodes = 0;
    let totalRels = 0;

    // Import node tables from Parquet files → CSV → COPY FROM
    // Also check for legacy node types (Package → Dependency)
    const LEGACY_TYPE_MAP: Record<string, NodeType> = {
      Package: 'Dependency',
    };

    for (const type of NODE_TYPES) {
      // Check for both current and legacy file names
      const fileName = `nodes_${type}.parquet`;
      let fileData = entries[fileName];

      // Check for legacy type name
      const legacyName = Object.entries(LEGACY_TYPE_MAP).find(
        ([, v]) => v === type,
      )?.[0];
      if (!fileData && legacyName) {
        fileData = entries[`nodes_${legacyName}.parquet`];
      }
      if (!fileData) continue;

      onProgress?.(`Importing ${type} nodes`);
      const arrowTable = await parquetToArrow(fileData);
      const columns = NODE_COLUMN_NAMES[type] as string[];