Update bug.yaml

.github/ISSUE_TEMPLATE/bug.yaml

@@ -0,0 +1,48 @@
+name: Bug Report
+description: File a bug report
+title: "[Bug] "
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+  - type: textarea
+    id: repro
+    attributes:
+      label: Reproduction steps
+      description: "How do you trigger this bug? Please walk us through it step by step."
+      value: |
+        1.
+        2.
+        3.
+        ...
+      render: bash
+    validations:
+      required: true
+  - type: dropdown
+    id: version
+    attributes:
+      label: Version
+      description: What version of VS Code are you using?
+      options:
+        - Stable (Default)
+        - Insiders
+    validations:
+      required: true
+  - type: dropdown
+    id: os
+    attributes:
+      label: What operating system are you seeing the problem on?
+      multiple: true
+      options:
+        - All
+        - Windows
+        - macOS
+        - Linux
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell

package.json

@@ -27,7 +27,10 @@
     "activationEvents": [
         "onCommand:vscode-appwrite.Connect",
         "onView:Appwrite",
-        "onView:Projects",
+        "onView:Users",
+        "onView:Database",
+        "onView:Health",
+        "onView:Functions",
         "onCommand:vscode-appwrite.AddProject",
         "onCommand:vscode-appwrite.CreateTag"
     ],
@@ -202,6 +205,11 @@
                 "icon": "$(plus)",
                 "category": "Appwrite"
             },
+            {
+                "command": "vscode-appwrite.setActiveProject",
+                "title": "Set as active",
+                "category": "Appwrite"
+            },
             {
                 "command": "vscode-appwrite.refreshProjects",
                 "title": "Refresh projects",
@@ -335,9 +343,29 @@
         ],
         "views": {
             "Appwrite": [
+                {
+                    "id": "Users",
+                    "name": "Users"
+                },
+                {
+                    "id": "Database",
+                    "name": "Database"
+                },
+                {
+                    "id": "Storage",
+                    "name": "Storage"
+                },
+                {
+                    "id": "Health",
+                    "name": "Health"
+                },
                 {
                     "id": "Projects",
                     "name": "Projects"
+                },
+                {
+                    "id": "Functions",
+                    "name": "Functions (Preview)"
                 }
             ]
         },
@@ -353,11 +381,6 @@
         ],
         "menus": {
             "view/title": [
-                {
-                    "command": "vscode-appwrite.addProject",
-                    "when": "view == Projects",
-                    "group": "navigation"
-                },
                 {
                     "command": "vscode-appwrite.OpenUsersDocumentation",
                     "when": "view == Users",
@@ -517,6 +540,11 @@
                     "when": "viewItem =~ /^(permission)$/",
                     "group": "inline"
                 },
+                {
+                    "command": "vscode-appwrite.setActiveProject",
+                    "when": "viewItem =~ /^(appwriteProject)$/",
+                    "group": "inline"
+                },
                 {
                     "command": "vscode-appwrite.removeProject",
                     "when": "viewItem =~ /(appwriteProject)/"

src/client.ts

@@ -42,10 +42,3 @@ export function createAppwriteClient(config?: AppwriteProjectConfiguration): voi
     storageClient = undefined;
     functionsClient = undefined;
 }
-
-export function createAppwriteSdk(config: AppwriteProjectConfiguration): Client {
-    const client = new AppwriteSDK.Client();
-    const { endpoint, projectId, secret, selfSigned } = config;
-    client.setEndpoint(endpoint).setProject(projectId).setKey(secret).setSelfSigned(selfSigned);
-    return client;
-}

src/commands/project/setActiveProject.ts

@@ -0,0 +1,14 @@
+import { setActiveProjectId } from '../../settings';
+import { ProjectTreeItem } from "../../tree/projects/ProjectTreeItem";
+
+export async function setActiveProject(treeItem: ProjectTreeItem): Promise<void> {
+    if (treeItem === undefined) {
+        return;
+    }
+
+    if (!(treeItem instanceof ProjectTreeItem)) {
+        return;
+    }
+
+    await setActiveProjectId(treeItem.project.projectId);
+}

src/commands/registerCommands.ts

@@ -23,25 +23,26 @@ import { openUserInConsole } from "./users/openUserInConsole";
 import { refreshUsersList } from "./users/refreshUsersList";
 import { viewUserPrefs } from "./users/viewUserPrefs";
 import { editPermission } from "./database/permissions/editPermission";
+import { setActiveProject } from "./project/setActiveProject";
 import { removeProject } from "./project/removeProject";
-import { createTag } from "./functions/createTag";
-import { createExecution } from "./functions/createExecution";
-import { activateTag } from "./functions/activateTag";
-import { editValue } from "./common/editValue";
-import { deleteFunction } from "./functions/deleteFunction";
-import { createFunction } from "./functions/createFunction";
-import { createFunctionVar } from "./functions/createFunctionVar";
-import { deleteFunctionVar } from "./functions/deleteFunctionVar";
-import { deleteTag } from "./functions/deleteTag";
-import { viewExecutionErrors } from "./functions/viewExecutionErrors";
-import { viewExecutionOutput } from "./functions/viewExecutionOutput";
-import { copyExecutionErrors } from "./functions/copyExecutionErrors";
-import { copyExecutionOutput } from "./functions/copyExecutionOutput";
-import { openExecutionsInBrowser } from "./functions/openExecutionsInBrowser";
-import { openFunctionSettingsInBrowser } from "./functions/openFunctionSettingsInBrowser";
-import { openFunctionTagsInBrowser } from "./functions/openFunctionTagsInBrowser";
+import { createTag } from './functions/createTag';
+import { createExecution } from './functions/createExecution';
+import { activateTag } from './functions/activateTag';
+import { editValue } from './common/editValue';
+import { deleteFunction } from './functions/deleteFunction';
+import { createFunction } from './functions/createFunction';
+import { createFunctionVar } from './functions/createFunctionVar';
+import { deleteFunctionVar } from './functions/deleteFunctionVar';
+import { deleteTag } from './functions/deleteTag';
+import { viewExecutionErrors } from './functions/viewExecutionErrors';
+import { viewExecutionOutput } from './functions/viewExecutionOutput';
+import { copyExecutionErrors } from './functions/copyExecutionErrors';
+import { copyExecutionOutput } from './functions/copyExecutionOutput';
+import { openExecutionsInBrowser } from './functions/openExecutionsInBrowser';
+import { openFunctionSettingsInBrowser } from './functions/openFunctionSettingsInBrowser';
+import { openFunctionTagsInBrowser } from './functions/openFunctionTagsInBrowser';
 
-import { viewMore } from "./common/viewMore";
+import { viewMore } from './common/viewMore';
 
 class CommandRegistrar {
     constructor(private readonly context: ExtensionContext) {}
@@ -107,6 +108,7 @@ export function registerCommands(context: ExtensionContext): void {
     registerCommand("editPermission", editPermission, "database");
 
     /** Health **/
+    registerCommand("refreshHealth", undefined, "health");
     registerCommand("openHealthDocumentation", () => openDocumentation("health"));
 
     /** Storage **/
@@ -115,6 +117,7 @@ export function registerCommands(context: ExtensionContext): void {
 
     /** Projects **/
     registerCommand("addProject", connectAppwrite, "all");
+    registerCommand("setActiveProject", setActiveProject, "all");
     registerCommand("refreshProjects", undefined, "projects");
     registerCommand("removeProject", removeProject, "all");
 

src/extension.ts

@@ -3,13 +3,28 @@ import { createAppwriteClient } from "./client";
 import { registerCommands } from "./commands/registerCommands";
 import { ext } from "./extensionVariables";
 import { getActiveProjectConfiguration } from "./settings";
+import { DatabaseTreeItemProvider } from "./tree/database/DatabaseTreeItemProvider";
+import { FunctionsTreeItemProvider } from './tree/functions/FunctionsTreeItemProvider';
+import { HealthTreeItemProvider } from "./tree/health/HealthTreeItemProvider";
 import { ProjectsTreeItemProvider } from "./tree/projects/ProjectsTreeItemProvider";
+import { StorageTreeItemProvider } from "./tree/storage/StorageTreeItemProvider";
+import { UserTreeItemProvider } from "./tree/users/UserTreeItemProvider";
 import { createAppwriteOutputChannel } from "./ui/AppwriteOutputChannel";
 
 export async function activate(context: vscode.ExtensionContext): Promise<void> {
+    const userTreeItemProvider = new UserTreeItemProvider();
+    const healthTreeItemProvider = new HealthTreeItemProvider();
+    const databaseTreeItemProvider = new DatabaseTreeItemProvider();
+    const storageTreeItemProvider = new StorageTreeItemProvider();
     const projectsTreeItemProvider = new ProjectsTreeItemProvider();
+    const functionsTreeItemProvider = new FunctionsTreeItemProvider();
 
+    vscode.window.registerTreeDataProvider("Users", userTreeItemProvider);
+    vscode.window.registerTreeDataProvider("Health", healthTreeItemProvider);
+    vscode.window.registerTreeDataProvider("Database", databaseTreeItemProvider);
+    vscode.window.registerTreeDataProvider("Storage", storageTreeItemProvider);
     vscode.window.registerTreeDataProvider("Projects", projectsTreeItemProvider);
+    vscode.window.registerTreeDataProvider("Functions", functionsTreeItemProvider);
 
     const activeProject = await getActiveProjectConfiguration();
     createAppwriteClient(activeProject);
@@ -18,7 +33,12 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     ext.outputChannel = createAppwriteOutputChannel("Appwrite", "appwrite");
 
     ext.tree = {
+        users: userTreeItemProvider,
+        health: healthTreeItemProvider,
+        database: databaseTreeItemProvider,
+        storage: storageTreeItemProvider,
         projects: projectsTreeItemProvider,
+        functions: functionsTreeItemProvider
     };
 
     registerCommands(context);

src/extensionVariables.ts

@@ -1,6 +1,7 @@
 import { ExtensionContext } from "vscode";
 import { DatabaseTreeItemProvider } from './tree/database/DatabaseTreeItemProvider';
 import { FunctionsTreeItemProvider } from './tree/functions/FunctionsTreeItemProvider';
+import { HealthTreeItemProvider } from './tree/health/HealthTreeItemProvider';
 import { ProjectsTreeItemProvider } from './tree/projects/ProjectsTreeItemProvider';
 import { StorageTreeItemProvider } from './tree/storage/StorageTreeItemProvider';
 import { UserTreeItemProvider } from './tree/users/UserTreeItemProvider';
@@ -8,6 +9,7 @@ import { AppwriteOutputChannel } from './ui/AppwriteOutputChannel';
 
 export type AppwriteTree = {
     users?: UserTreeItemProvider;
+    health?: HealthTreeItemProvider;
     database?: DatabaseTreeItemProvider;
     storage?: StorageTreeItemProvider;
     projects?: ProjectsTreeItemProvider;

src/settings.ts

@@ -30,6 +30,7 @@ export async function addProjectConfiguration(projectConfig: AppwriteProjectConf
     const projects = await getAppwriteProjects();
 
     await configuration.update("projects", [...projects, projectConfig], true);
+    await setActiveProjectId(projectConfig.projectId);
 }
 
 export async function getActiveProjectId(): Promise<string> {
@@ -52,9 +53,21 @@ export async function getActiveProjectConfiguration(): Promise<AppwriteProjectCo
             activeConfig = config;
         }
     });
+
+    if (activeConfig === undefined) {
+        activeConfig = configurations[0];
+        setActiveProjectId(configurations[0].projectId);
+    }
     return activeConfig;
 }
 
+export async function setActiveProjectId(projectId: string): Promise<void> {
+    const configuration = workspace.getConfiguration("appwrite");
+    await configuration.update("activeProjectId", projectId, true);
+    const active = await getActiveProjectConfiguration();
+    createAppwriteClient(active);
+}
+
 export async function updateActiveProjectId(): Promise<void> {
     const projects = await getAppwriteProjects();
     if (projects.length > 0) {

src/tree/database/DatabaseTreeItemProvider.ts

@@ -1,25 +1,13 @@
 import * as vscode from "vscode";
+import { client } from "../../client";
 import AppwriteCall from "../../utils/AppwriteCall";
-import { Client, Collection, CollectionsList } from "../../appwrite";
+import { Collection, CollectionsList } from "../../appwrite";
 import { CollectionTreeItem } from "./CollectionTreeItem";
 import { AppwriteSDK } from "../../constants";
 import { ext } from '../../extensionVariables';
 import { AppwriteTreeItemBase } from '../../ui/AppwriteTreeItemBase';
-import { ProjectTreeItem } from '../projects/ProjectTreeItem';
-import { Database } from '../../appwrite/Database';
-
-export class DatabaseTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeItem> {
-
-    private databaseClient: Database;
-
-    constructor(parent: ProjectTreeItem, private readonly sdk: Client) {
-        super(parent, 'Database');
-        this.databaseClient = new Database(sdk);
-        this.iconPath = new vscode.ThemeIcon('database');
-    }
-
-    collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
 
+export class DatabaseTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
     private _onDidChangeTreeData: vscode.EventEmitter<vscode.TreeItem | undefined | void> = new vscode.EventEmitter<
         CollectionTreeItem | undefined | void
     >();
@@ -41,12 +29,15 @@ export class DatabaseTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeIt
 
     async getChildren(parent?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
         ext.outputChannel?.appendLine('getChildren for: ' + parent?.label);
+        if (client === undefined) {
+            return Promise.resolve([]);
+        }
 
         if (parent instanceof AppwriteTreeItemBase) {
             return await parent.getChildren?.() ?? [];
         }
 
-        const databaseSdk = new AppwriteSDK.Database(this.sdk);
+        const databaseSdk = new AppwriteSDK.Database(client);
 
         const collectionsList = await AppwriteCall<CollectionsList, CollectionsList>(databaseSdk.listCollections());
         if (collectionsList) {

src/tree/functions/FunctionsTreeItemProvider.ts

@@ -1,18 +1,13 @@
 import * as vscode from "vscode";
-import { Client, Function, FunctionsList } from "../../appwrite";
+import { client } from "../../client";
+import { Function, FunctionsList } from "../../appwrite";
 import { AppwriteSDK } from "../../constants";
 import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
 import { ext } from "../../extensionVariables";
 import { EventEmitter, TreeItem } from "vscode";
 import { FunctionTreeItem } from "./FunctionTreeItem";
-import { ProjectTreeItem } from "../projects/ProjectTreeItem";
-
-export class FunctionsTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeItem> {
-    constructor(parent: ProjectTreeItem, private readonly sdk: Client) {
-        super(parent, "Functions");
-        this.iconPath = new vscode.ThemeIcon('github-action');
-    }
 
+export class FunctionsTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
     private _onDidChangeTreeData: EventEmitter<TreeItem | undefined | void> = new EventEmitter<TreeItem | undefined | void>();
 
     readonly onDidChangeTreeData: vscode.Event<vscode.TreeItem | undefined | void> = this._onDidChangeTreeData.event;
@@ -30,18 +25,28 @@ export class FunctionsTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeI
         return element;
     }
 
-    collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
-
-    async getChildren(): Promise<vscode.TreeItem[]> {
-        const functionsSdk = new AppwriteSDK.Functions(this.sdk);
-
-        const list: FunctionsList = await functionsSdk.list();
-
-        if (list) {
-            const functionTreeItems = list.functions.map((func: Function) => new FunctionTreeItem(func, this)) ?? [];
-            return functionTreeItems;
+    async getChildren(parent?: AppwriteTreeItemBase | TreeItem): Promise<vscode.TreeItem[]> {
+        if (client === undefined) {
+            return Promise.resolve([]);
         }
 
-        return [{ label: "No functions found" }];
+        if (parent === undefined) {
+            const functionsSdk = new AppwriteSDK.Functions(client);
+
+            const list: FunctionsList = await functionsSdk.list();
+
+            if (list) {
+                const functionTreeItems = list.functions.map((func: Function) => new FunctionTreeItem(func, this)) ?? [];
+                return functionTreeItems;
+            }
+
+            return [{ label: "No functions found" }];
+        }
+
+        if (parent instanceof AppwriteTreeItemBase) {
+            return await parent.getChildren?.() ?? [];
+        }
+
+        return [];
     }
 }

src/tree/health/HealthTreeItemProvider.ts

@@ -1,31 +1,20 @@
 import * as vscode from "vscode";
+import { healthClient } from "../../client";
 import { ext } from "../../extensionVariables";
 import { HealthTreeItem } from "./HealthTreeItem";
 import * as dayjs from "dayjs";
 import * as localizedFormat from "dayjs/plugin/localizedFormat";
-import { Health, healthTooltips } from "../../appwrite/Health";
-import { AppwriteHealth, Client } from "../../appwrite";
+import { healthTooltips } from "../../appwrite/Health";
+import { AppwriteHealth } from "../../appwrite";
 import { promiseWithTimeout } from "../../utils/promiseWithTimeout";
-import { AppwriteTreeItemBase } from '../../ui/AppwriteTreeItemBase';
-import { ProjectTreeItem } from '../projects/ProjectTreeItem';
+// dayjs.extend(relativeTime);
 dayjs.extend(localizedFormat);
 
-export class HealthParentTreeItem extends AppwriteTreeItemBase<ProjectTreeItem> {
-
-    private readonly healthClient: Health;
-
-    constructor(parent: ProjectTreeItem, sdk: Client) {
-        super(parent, 'Health');
-        this.healthClient = new Health(sdk);
-        this.iconPath = new vscode.ThemeIcon('pulse');
-    }
-
+export class HealthTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
     private _onDidChangeTreeData: vscode.EventEmitter<HealthTreeItem | undefined | void> = new vscode.EventEmitter<
         HealthTreeItem | undefined | void
     >();
 
-    label = 'Health';
-
     private lastChecked: Date = new Date();
 
     readonly onDidChangeTreeData: vscode.Event<HealthTreeItem | undefined | void> = this._onDidChangeTreeData.event;
@@ -38,9 +27,11 @@ export class HealthParentTreeItem extends AppwriteTreeItemBase<ProjectTreeItem>
         return element;
     }
 
-    collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
-
     async getChildren(element?: HealthTreeItem): Promise<vscode.TreeItem[]> {
+        if (healthClient === undefined) {
+            return [];
+        }
+
         // get children for root
         if (element === undefined) {
             try {
@@ -48,7 +39,7 @@ export class HealthParentTreeItem extends AppwriteTreeItemBase<ProjectTreeItem>
                     10000,
                     async () => {
                         try {
-                            return await this.healthClient?.checkup();
+                            return await healthClient?.checkup();
                         } catch (e) {
                             ext.outputChannel?.append('Error: ' + e.message);
                             vscode.window.showErrorMessage('Could not connect to Appwrite project');

src/tree/projects/AddProjectTreeItem.ts

@@ -1,16 +0,0 @@
-import { ThemeIcon, TreeItem } from "vscode";
-
-export class AddProjectTreeItem extends TreeItem {
-    iconPath = new ThemeIcon("add");
-
-    constructor() {
-        super("Add Appwrite project");
-    }
-
-    contextValue = "";
-
-    command = {
-        command: "vscode-appwrite.addProject",
-        title: "Add Appwrite project",
-    };
-}

src/tree/projects/ProjectTreeItem.ts

@@ -1,36 +1,15 @@
-import { TreeItem, TreeItemCollapsibleState } from "vscode";
-import { Client } from "../../appwrite";
-import { createAppwriteSdk } from "../../client";
+import { ThemeIcon, TreeItem } from "vscode";
 import { AppwriteProjectConfiguration } from "../../settings";
-import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
-import { DatabaseTreeItemProvider } from "../database/DatabaseTreeItemProvider";
-import { FunctionsTreeItemProvider } from "../functions/FunctionsTreeItemProvider";
-import { HealthParentTreeItem } from "../health/HealthParentTreeItem";
-import { StorageTreeItemProvider } from "../storage/StorageTreeItemProvider";
-import { UserTreeItemProvider } from "../users/UserTreeItemProvider";
-
-export class ProjectTreeItem extends AppwriteTreeItemBase {
-    private readonly sdk: Client;
 
+export class ProjectTreeItem extends TreeItem {
     constructor(public readonly project: AppwriteProjectConfiguration, active: boolean) {
-        super(undefined, "Project");
+        super("Project");
+        this.iconPath = new ThemeIcon("rocket");
         const name = project.nickname ?? "Project";
-        this.label = `${name}`;
+        this.label = `${name} ${active ? "(Active)" : ""}`;
         this.contextValue = `appwriteProject${active ? "_active" : ""}`;
-        this.description = project.endpoint;
-
-        this.sdk = createAppwriteSdk(project);
+        if (!active) {
+            this.command = { command: "vscode-appwrite.setActiveProject", title: "Set active", arguments: [this] };
+        }
     }
-
-    async getChildren(): Promise<TreeItem[]> {
-        return [
-            new DatabaseTreeItemProvider(this, this.sdk),
-            new FunctionsTreeItemProvider(this, this.sdk),
-            new UserTreeItemProvider(this, this.sdk),
-            new StorageTreeItemProvider(this, this.sdk),
-            new HealthParentTreeItem(this, this.sdk),
-        ];
-    }
-
-    collapsibleState = TreeItemCollapsibleState.Collapsed;
 }

src/tree/projects/ProjectsTreeItemProvider.ts

@@ -1,6 +1,5 @@
 import * as vscode from "vscode";
 import { getActiveProjectId, getAppwriteProjects } from "../../settings";
-import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
 import { ProjectTreeItem } from "./ProjectTreeItem";
 
 export class ProjectsTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
@@ -26,18 +25,12 @@ export class ProjectsTreeItemProvider implements vscode.TreeDataProvider<vscode.
         return element;
     }
 
-    async getChildren(element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
-        if (element instanceof AppwriteTreeItemBase) {
-            return element.getChildren?.() ?? [];
-        }
-
+    async getChildren(_element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
         const configs = await getAppwriteProjects();
         if (configs === undefined || configs.length === 0) {
             return [];
         }
         const activeProjectId = await getActiveProjectId();
-        const projectTreeItems = configs.map((config) => new ProjectTreeItem(config, config.projectId === activeProjectId));
-
-        return projectTreeItems;
+        return configs.map((config) => new ProjectTreeItem(config, config.projectId === activeProjectId));
     }
 }

src/tree/storage/StorageTreeItemProvider.ts

@@ -1,37 +1,30 @@
-import { Event, EventEmitter, ThemeIcon, TreeItem, TreeItemCollapsibleState } from 'vscode';
-import { Client } from "../../appwrite";
-import { Storage } from "../../appwrite/Storage";
-import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
-import { ProjectTreeItem } from "../projects/ProjectTreeItem";
+import * as vscode from "vscode";
+import { storageClient } from "../../client";
 import { FileTreeItem } from "./FileTreeItem";
 
-export class StorageTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeItem> {
-    constructor(parent: ProjectTreeItem, private readonly sdk: Client) {
-        super(parent, "Storage");
-        this.iconPath = new ThemeIcon('archive');
-    }
-
-    private _onDidChangeTreeData: EventEmitter<TreeItem | undefined | void> = new EventEmitter<
-        TreeItem | undefined | void
+export class StorageTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
+    private _onDidChangeTreeData: vscode.EventEmitter<vscode.TreeItem | undefined | void> = new vscode.EventEmitter<
+        vscode.TreeItem | undefined | void
     >();
 
-    readonly onDidChangeTreeData: Event<TreeItem | undefined | void> = this._onDidChangeTreeData.event;
+    readonly onDidChangeTreeData: vscode.Event<vscode.TreeItem | undefined | void> = this._onDidChangeTreeData.event;
 
     refresh(): void {
         this._onDidChangeTreeData.fire();
     }
 
-    getTreeItem(element: TreeItem): TreeItem {
+    getTreeItem(element: vscode.TreeItem): vscode.TreeItem {
         return element;
     }
 
-    collapsibleState = TreeItemCollapsibleState.Collapsed;
+    async getChildren(_element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
+        if (storageClient === undefined) {
+            return [];
+        }
 
-    async getChildren(_element?: TreeItem): Promise<TreeItem[]> {
-        const storageClient = new Storage(this.sdk);
         const files = await storageClient.listFiles();
         if (files === undefined || files?.files.length === 0) {
-            const noStorage = new TreeItem("No files found");
+            const noStorage = new vscode.TreeItem("No files found");
             return [noStorage];
         }
         return files.files.map((file) => new FileTreeItem(file));

src/tree/users/UserTreeItem.ts

@@ -1,53 +1,14 @@
 import { User } from "../../appwrite";
 import * as vscode from "vscode";
-import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
-import { UserTreeItemProvider } from "./UserTreeItemProvider";
-import { ChildTreeItem } from '../ChildTreeItem';
-import { ThemeIcon } from 'vscode';
-import { UserPrefsTreeItem } from './properties/UserPrefsTreeItem';
 
-export class UserTreeItem extends AppwriteTreeItemBase<UserTreeItemProvider> {
-    constructor(parent: UserTreeItemProvider, public readonly user: User) {
-        super(parent, user.email);
+export class UserTreeItem extends vscode.TreeItem {
+    constructor(public readonly user: User) {
+        super(user.email);
         console.log(user);
         this.label = `${user.email}`;
         this.tooltip = user.emailVerification ? "Verified" : "Unverified";
         this.iconPath = new vscode.ThemeIcon(user.emailVerification ? "verified" : "unverified");
     }
-    async getChildren(): Promise<vscode.TreeItem[]> {
-        const regDate = new Date();
-
-        regDate.setMilliseconds(this.user.registration);
-        const items: vscode.TreeItem[] = [
-            new ChildTreeItem(this, {
-                contextValue: "user.name",
-                label: this.user.name || "Unfilled",
-                iconPath: new ThemeIcon("person"),
-                description: "Name",
-            }),
-            new ChildTreeItem(this, {
-                contextValue: "user.email",
-                label: this.user.email,
-                iconPath: new ThemeIcon("mail"),
-                description: "Email",
-            }),
-            new ChildTreeItem(this, {
-                contextValue: "user.registration",
-                label: regDate.toDateString(),
-                iconPath: new vscode.ThemeIcon("calendar"),
-                description: "Joined",
-            }),
-            new ChildTreeItem(this, {
-                label: this.user.$id,
-                description: "User ID",
-                iconPath: new vscode.ThemeIcon("key"),
-                contextValue: "user.id",
-            }),
-            new UserPrefsTreeItem(this),
-        ];
-
-        return items;
-    }
 
     collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
     contextValue = "user";

src/tree/users/UserTreeItemProvider.ts

@@ -1,18 +1,15 @@
 import * as vscode from "vscode";
+import { client } from "../../client";
 import AppwriteCall from "../../utils/AppwriteCall";
-import { Client, User, UsersList } from "../../appwrite";
+import { User, UsersList } from "../../appwrite";
+import { ThemeIcon } from "vscode";
+import { UserPrefsTreeItem } from "./properties/UserPrefsTreeItem";
+import { ChildTreeItem } from "../ChildTreeItem";
 import { UserTreeItem } from "./UserTreeItem";
-import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
-import { ProjectTreeItem } from "../projects/ProjectTreeItem";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const sdk = require("node-appwrite");
 
-export class UserTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeItem> {
-    constructor(parent: ProjectTreeItem, private readonly sdk: Client) {
-        super(parent, "Users");
-        this.iconPath = new vscode.ThemeIcon('account');
-
-    }
+export class UserTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
     private _onDidChangeTreeData: vscode.EventEmitter<UserTreeItem | undefined | void> = new vscode.EventEmitter<
         UserTreeItem | undefined | void
     >();
@@ -27,14 +24,48 @@ export class UserTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeItem>
         return element;
     }
 
-    collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
+    async getChildren(element?: UserTreeItem): Promise<vscode.TreeItem[]> {
+        if (client === undefined) {
+            return Promise.resolve([]);
+        }
 
-    async getChildren(): Promise<vscode.TreeItem[]> {
+        if (element instanceof UserTreeItem) {
+            const regDate = new Date();
+            regDate.setMilliseconds(element.user.registration);
+            const items: vscode.TreeItem[] = [
+                new ChildTreeItem(element, {
+                    contextValue: "user.name",
+                    label: element.user.name || "Unfilled",
+                    iconPath: new ThemeIcon("person"),
+                    description: "Name",
+                }),
+                new ChildTreeItem(element, {
+                    contextValue: "user.email",
+                    label: element.user.email,
+                    iconPath: new ThemeIcon("mail"),
+                    description: "Email",
+                }),
+                new ChildTreeItem(element, {
+                    contextValue: "user.registration",
+                    label: regDate.toDateString(),
+                    iconPath: new vscode.ThemeIcon("calendar"),
+                    description: "Joined",
+                }),
+                new ChildTreeItem(element, {
+                    label: element.user.$id,
+                    description: "User ID",
+                    iconPath: new vscode.ThemeIcon("key"),
+                    contextValue: "user.id",
+                }),
+                new UserPrefsTreeItem(element),
+            ];
+            return Promise.resolve(items);
+        }
 
-        const usersSdk = new sdk.Users(this.sdk);
+        const usersSdk = new sdk.Users(client);
         const usersList = await AppwriteCall<UsersList, UsersList>(usersSdk.list());
         if (usersList) {
-            const userTreeItems = usersList.users.map((user: User) => new UserTreeItem(this, user)) ?? [];
+            const userTreeItems = usersList.users.map((user: User) => new UserTreeItem(user)) ?? [];
             const headerItem: vscode.TreeItem = {
                 label: `Total users: ${usersList.sum}`,
             };