Render nodes for local database items (#1759)

Author: shati-patel

extensions/ql-vscode/src/databases/db-item.ts

@@ -2,6 +2,8 @@
 
 export enum DbItemKind {
   RootLocal = 'RootLocal',
+  LocalList = 'LocalList',
+  LocalDatabase = 'LocalDatabase',
   RootRemote = 'RootRemote',
   RemoteSystemDefinedList = 'RemoteSystemDefinedList',
   RemoteUserDefinedList = 'RemoteUserDefinedList',
@@ -11,6 +13,25 @@ export enum DbItemKind {
 
 export interface RootLocalDbItem {
   kind: DbItemKind.RootLocal;
+  children: LocalDbItem[];
+}
+
+export type LocalDbItem =
+  | LocalListDbItem
+  | LocalDatabaseDbItem;
+
+export interface LocalListDbItem {
+  kind: DbItemKind.LocalList;
+  listName: string;
+  databases: LocalDatabaseDbItem[];
+}
+
+export interface LocalDatabaseDbItem {
+  kind: DbItemKind.LocalDatabase;
+  databaseName: string;
+  dateAdded: number;
+  language: string;
+  storagePath: string;
 }
 
 export interface RootRemoteDbItem {
@@ -22,6 +43,7 @@ export type DbItem =
   | RootLocalDbItem
   | RootRemoteDbItem
   | RemoteDbItem
+  | LocalDbItem;
 
 export type RemoteDbItem =
   | RemoteSystemDefinedListDbItem

extensions/ql-vscode/src/databases/db-manager.ts

@@ -29,7 +29,7 @@ export class DbManager {
 
     return ValueResult.ok([
       createRemoteTree(configResult.value),
-      createLocalTree()
+      createLocalTree(configResult.value)
     ]);
   }
 

extensions/ql-vscode/src/databases/db-tree-creator.ts

@@ -1,6 +1,8 @@
-import { DbConfig, RemoteRepositoryList } from './config/db-config';
+import { DbConfig, LocalDatabase, LocalList, RemoteRepositoryList } from './config/db-config';
 import {
   DbItemKind,
+  LocalDatabaseDbItem,
+  LocalListDbItem,
   RemoteOwnerDbItem,
   RemoteRepoDbItem,
   RemoteSystemDefinedListDbItem,
@@ -31,10 +33,16 @@ export function createRemoteTree(dbConfig: DbConfig): RootRemoteDbItem {
   };
 }
 
-export function createLocalTree(): RootLocalDbItem {
-  // This will be fleshed out further in the future.
+export function createLocalTree(dbConfig: DbConfig): RootLocalDbItem {
+  const localLists = dbConfig.databases.local.lists.map(createLocalList);
+  const localDbs = dbConfig.databases.local.databases.map(createLocalDb);
+
   return {
-    kind: DbItemKind.RootLocal
+    kind: DbItemKind.RootLocal,
+    children: [
+      ...localLists,
+      ...localDbs
+    ]
   };
 }
 
@@ -68,3 +76,21 @@ function createRepoItem(repo: string): RemoteRepoDbItem {
     repoFullName: repo
   };
 }
+
+function createLocalList(list: LocalList): LocalListDbItem {
+  return {
+    kind: DbItemKind.LocalList,
+    listName: list.name,
+    databases: list.databases.map(createLocalDb)
+  };
+}
+
+function createLocalDb(db: LocalDatabase): LocalDatabaseDbItem {
+  return {
+    kind: DbItemKind.LocalDatabase,
+    databaseName: db.name,
+    dateAdded: db.dateAdded,
+    language: db.language,
+    storagePath: db.storagePath
+  };
+}

extensions/ql-vscode/src/databases/ui/db-item-mapper.ts

@@ -1,5 +1,6 @@
 import { DbItem, DbItemKind } from '../db-item';
 import {
+  createDbTreeViewItemLocalDatabase,
   createDbTreeViewItemOwner,
   createDbTreeViewItemRepo,
   createDbTreeViewItemRoot,
@@ -15,7 +16,7 @@ export function mapDbItemToTreeViewItem(dbItem: DbItem): DbTreeViewItem {
         dbItem,
         'local',
         'Local databases',
-        []);
+        dbItem.children.map(c => mapDbItemToTreeViewItem(c)));
 
     case DbItemKind.RootRemote:
       return createDbTreeViewItemRoot(
@@ -45,5 +46,17 @@ export function mapDbItemToTreeViewItem(dbItem: DbItem): DbTreeViewItem {
       return createDbTreeViewItemRepo(
         dbItem,
         dbItem.repoFullName);
+
+    case DbItemKind.LocalList:
+      return createDbTreeViewItemUserDefinedList(
+        dbItem,
+        dbItem.listName,
+        dbItem.databases.map(mapDbItemToTreeViewItem));
+
+    case DbItemKind.LocalDatabase:
+      return createDbTreeViewItemLocalDatabase(
+        dbItem,
+        dbItem.databaseName,
+        dbItem.language);
   }
 }

extensions/ql-vscode/src/databases/ui/db-tree-view-item.ts

@@ -1,6 +1,8 @@
 import * as vscode from 'vscode';
 import {
   DbItem,
+  LocalDatabaseDbItem,
+  LocalListDbItem,
   RemoteOwnerDbItem,
   RemoteRepoDbItem,
   RemoteSystemDefinedListDbItem,
@@ -70,7 +72,7 @@ export function createDbTreeViewItemSystemDefinedList(
 }
 
 export function createDbTreeViewItemUserDefinedList(
-  dbItem: RemoteUserDefinedListDbItem,
+  dbItem: LocalListDbItem | RemoteUserDefinedListDbItem,
   listName: string,
   children: DbTreeViewItem[]
 ): DbTreeViewItem {
@@ -108,3 +110,17 @@ export function createDbTreeViewItemRepo(
     vscode.TreeItemCollapsibleState.None,
     []);
 }
+
+export function createDbTreeViewItemLocalDatabase(
+  dbItem: LocalDatabaseDbItem,
+  databaseName: string,
+  language: string
+): DbTreeViewItem {
+  return new DbTreeViewItem(
+    dbItem,
+    new vscode.ThemeIcon('database'),
+    databaseName,
+    `Language: ${language}`,
+    vscode.TreeItemCollapsibleState.None,
+    []);
+}

extensions/ql-vscode/src/vscode-tests/minimal-workspace/databases/db-panel.test.ts

@@ -8,7 +8,7 @@ import { DbManager } from '../../../databases/db-manager';
 import { DbConfigStore } from '../../../databases/config/db-config-store';
 import { DbTreeDataProvider } from '../../../databases/ui/db-tree-data-provider';
 import { DbPanel } from '../../../databases/ui/db-panel';
-import { DbItemKind } from '../../../databases/db-item';
+import { DbItemKind, LocalDatabaseDbItem } from '../../../databases/db-item';
 import { DbTreeViewItem } from '../../../databases/ui/db-tree-view-item';
 import { ExtensionApp } from '../../../common/vscode/vscode-app';
 import { createMockExtensionContext } from '../../factories/extension-context';
@@ -235,6 +235,151 @@ describe('db panel', async () => {
     checkRemoteRepoItem(repoItems[1], 'owner1/repo2');
   });
 
+  it('should render local list nodes', async () => {
+    const dbConfig: DbConfig = {
+      databases: {
+        remote: {
+          repositoryLists: [],
+          owners: [],
+          repositories: []
+        },
+        local: {
+          lists: [
+            {
+              name: 'my-list-1',
+              databases: [
+                {
+                  name: 'db1',
+                  dateAdded: 1668428293677,
+                  language: 'cpp',
+                  storagePath: '/path/to/db1/',
+                },
+                {
+                  name: 'db2',
+                  dateAdded: 1668428472731,
+                  language: 'cpp',
+                  storagePath: '/path/to/db2/',
+                },
+              ],
+            },
+            {
+              name: 'my-list-2',
+              databases: [
+                {
+                  name: 'db3',
+                  dateAdded: 1668428472731,
+                  language: 'ruby',
+                  storagePath: '/path/to/db3/',
+                },
+              ],
+            },
+          ],
+          databases: []
+        },
+      },
+    };
+
+    await saveDbConfig(dbConfig);
+
+    const dbTreeItems = await dbTreeDataProvider.getChildren();
+
+    expect(dbTreeItems).to.be.ok;
+    const items = dbTreeItems!;
+    expect(items.length).to.equal(2);
+
+    const localRootNode = items[1];
+    expect(localRootNode.dbItem).to.be.ok;
+    expect(localRootNode.collapsibleState).to.equal(vscode.TreeItemCollapsibleState.Collapsed);
+    expect(localRootNode.children).to.be.ok;
+    expect(localRootNode.children.length).to.equal(2);
+
+    const localListItems = localRootNode.children.filter(item => item.dbItem?.kind === DbItemKind.LocalList);
+    expect(localListItems.length).to.equal(2);
+    checkLocalListItem(localListItems[0], 'my-list-1', [{
+      kind: DbItemKind.LocalDatabase,
+      databaseName: 'db1',
+      dateAdded: 1668428293677,
+      language: 'cpp',
+      storagePath: '/path/to/db1/',
+    },
+    {
+      kind: DbItemKind.LocalDatabase,
+      databaseName: 'db2',
+      dateAdded: 1668428472731,
+      language: 'cpp',
+      storagePath: '/path/to/db2/',
+    }]);
+    checkLocalListItem(localListItems[1], 'my-list-2', [
+      {
+        kind: DbItemKind.LocalDatabase,
+        databaseName: 'db3',
+        dateAdded: 1668428472731,
+        language: 'ruby',
+        storagePath: '/path/to/db3/',
+      },
+    ]);
+  });
+
+  it('should render local database nodes', async () => {
+    const dbConfig: DbConfig = {
+      databases: {
+        remote: {
+          repositoryLists: [],
+          owners: [],
+          repositories: []
+        },
+        local: {
+          lists: [],
+          databases: [
+            {
+              name: 'db1',
+              dateAdded: 1668428293677,
+              language: 'csharp',
+              storagePath: '/path/to/db1/',
+            },
+            {
+              name: 'db2',
+              dateAdded: 1668428472731,
+              language: 'go',
+              storagePath: '/path/to/db2/',
+            }
+          ]
+        }
+      }
+    };
+
+    await saveDbConfig(dbConfig);
+
+    const dbTreeItems = await dbTreeDataProvider.getChildren();
+
+    expect(dbTreeItems).to.be.ok;
+    const items = dbTreeItems!;
+    expect(items.length).to.equal(2);
+
+    const localRootNode = items[1];
+    expect(localRootNode.dbItem).to.be.ok;
+    expect(localRootNode.collapsibleState).to.equal(vscode.TreeItemCollapsibleState.Collapsed);
+    expect(localRootNode.children).to.be.ok;
+    expect(localRootNode.children.length).to.equal(2);
+
+    const localDatabaseItems = localRootNode.children.filter(item => item.dbItem?.kind === DbItemKind.LocalDatabase);
+    expect(localDatabaseItems.length).to.equal(2);
+    checkLocalDatabaseItem(localDatabaseItems[0], {
+      kind: DbItemKind.LocalDatabase,
+      databaseName: 'db1',
+      dateAdded: 1668428293677,
+      language: 'csharp',
+      storagePath: '/path/to/db1/',
+    });
+    checkLocalDatabaseItem(localDatabaseItems[1], {
+      kind: DbItemKind.LocalDatabase,
+      databaseName: 'db2',
+      dateAdded: 1668428472731,
+      language: 'go',
+      storagePath: '/path/to/db2/',
+    });
+  });
+
   async function saveDbConfig(dbConfig: DbConfig): Promise<void> {
     await fs.writeJson(dbConfigFilePath, dbConfig);
 
@@ -294,4 +439,31 @@ describe('db panel', async () => {
     expect(item.iconPath).to.deep.equal(new vscode.ThemeIcon('database'));
     expect(item.collapsibleState).to.equal(vscode.TreeItemCollapsibleState.None);
   }
+
+  function checkLocalListItem(
+    item: DbTreeViewItem,
+    listName: string,
+    databases: LocalDatabaseDbItem[]
+  ): void {
+    expect(item.label).to.equal(listName);
+    expect(item.tooltip).to.be.undefined;
+    expect(item.iconPath).to.be.undefined;
+    expect(item.collapsibleState).to.equal(vscode.TreeItemCollapsibleState.Collapsed);
+    expect(item.children).to.be.ok;
+    expect(item.children.length).to.equal(databases.length);
+
+    for (let i = 0; i < databases.length; i++) {
+      checkLocalDatabaseItem(item.children[i], databases[i]);
+    }
+  }
+
+  function checkLocalDatabaseItem(
+    item: DbTreeViewItem,
+    database: LocalDatabaseDbItem,
+  ): void {
+    expect(item.label).to.equal(database.databaseName);
+    expect(item.tooltip).to.equal(`Language: ${database.language}`);
+    expect(item.iconPath).to.deep.equal(new vscode.ThemeIcon('database'));
+    expect(item.collapsibleState).to.equal(vscode.TreeItemCollapsibleState.None);
+  }
 });