dcowan/vscode-appwrite
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Combine all providers into one

Browse source
This commit is contained in:
alexweininger 2021-07-19 21:31:58 -07:00
parent 883893aaab
commit acbdbd1bfd
13 changed files with 170 additions and 156 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
package.json
View file

@ -27,10 +27,7 @@
"activationEvents": [
"onCommand:vscode-appwrite.Connect",
"onView:Appwrite",
"onView:Users",
"onView:Database",
"onView:Health",
"onView:Functions",
"onView:Projects",
"onCommand:vscode-appwrite.AddProject",
"onCommand:vscode-appwrite.CreateTag"
],
@ -343,29 +340,9 @@
],
"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)"
}
]
},

7
src/client.ts
View file

@ -42,3 +42,10 @@ 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;
}

1
src/commands/registerCommands.ts
View file

@ -108,7 +108,6 @@ export function registerCommands(context: ExtensionContext): void {
registerCommand("editPermission", editPermission, "database");
/** Health **/
registerCommand("refreshHealth", undefined, "health");
registerCommand("openHealthDocumentation", () => openDocumentation("health"));
/** Storage **/

20
src/extension.ts
View file

@ -3,28 +3,13 @@ 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);
@ -33,12 +18,7 @@ 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);

2
src/extensionVariables.ts
View file

@ -1,7 +1,6 @@
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';
@ -9,7 +8,6 @@ import { AppwriteOutputChannel } from './ui/AppwriteOutputChannel';
export type AppwriteTree = {
users?: UserTreeItemProvider;
health?: HealthTreeItemProvider;
database?: DatabaseTreeItemProvider;
storage?: StorageTreeItemProvider;
projects?: ProjectsTreeItemProvider;

23
src/tree/database/DatabaseTreeItemProvider.ts
View file

@ -1,13 +1,25 @@
import * as vscode from "vscode";
import { client } from "../../client";
import AppwriteCall from "../../utils/AppwriteCall";
import { Collection, CollectionsList } from "../../appwrite";
import { Client, 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
>();
@ -29,15 +41,12 @@ export class DatabaseTreeItemProvider implements vscode.TreeDataProvider<vscode.
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(client);
const databaseSdk = new AppwriteSDK.Database(this.sdk);
const collectionsList = await AppwriteCall<CollectionsList, CollectionsList>(databaseSdk.listCollections());
if (collectionsList) {

43
src/tree/functions/FunctionsTreeItemProvider.ts
View file

@ -1,13 +1,18 @@
import * as vscode from "vscode";
import { client } from "../../client";
import { Function, FunctionsList } from "../../appwrite";
import { Client, 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;
@ -25,28 +30,18 @@ export class FunctionsTreeItemProvider implements vscode.TreeDataProvider<vscode
return element;
}
async getChildren(parent?: AppwriteTreeItemBase | TreeItem): Promise<vscode.TreeItem[]> {
if (client === undefined) {
return Promise.resolve([]);
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;
}
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 [];
return [{ label: "No functions found" }];
}
}

29
src/tree/health/HealthTreeItemProvider.ts → src/tree/health/HealthParentTreeItem.ts
View file

@ -1,20 +1,31 @@
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 { healthTooltips } from "../../appwrite/Health";
import { AppwriteHealth } from "../../appwrite";
import { Health, healthTooltips } from "../../appwrite/Health";
import { AppwriteHealth, Client } from "../../appwrite";
import { promiseWithTimeout } from "../../utils/promiseWithTimeout";
// dayjs.extend(relativeTime);
import { AppwriteTreeItemBase } from '../../ui/AppwriteTreeItemBase';
import { ProjectTreeItem } from '../projects/ProjectTreeItem';
dayjs.extend(localizedFormat);
export class HealthTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
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');
}
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;
@ -27,11 +38,9 @@ export class HealthTreeItemProvider implements vscode.TreeDataProvider<vscode.Tr
return element;
}
async getChildren(element?: HealthTreeItem): Promise<vscode.TreeItem[]> {
if (healthClient === undefined) {
return [];
}
collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
async getChildren(element?: HealthTreeItem): Promise<vscode.TreeItem[]> {
// get children for root
if (element === undefined) {
try {
@ -39,7 +48,7 @@ export class HealthTreeItemProvider implements vscode.TreeDataProvider<vscode.Tr
10000,
async () => {
try {
return await healthClient?.checkup();
return await this.healthClient?.checkup();
} catch (e) {
ext.outputChannel?.append('Error: ' + e.message);
vscode.window.showErrorMessage('Could not connect to Appwrite project');

36
src/tree/projects/ProjectTreeItem.ts
View file

@ -1,15 +1,35 @@
import { ThemeIcon, TreeItem } from "vscode";
import { TreeItem, TreeItemCollapsibleState } from "vscode";
import { Client } from "../../appwrite";
import { createAppwriteSdk } from "../../client";
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("Project");
this.iconPath = new ThemeIcon("rocket");
super(undefined, "Project");
const name = project.nickname ?? "Project";
this.label = `${name} ${active ? "(Active)" : ""}`;
this.label = `${name}`;
this.contextValue = `appwriteProject${active ? "_active" : ""}`;
if (!active) {
this.command = { command: "vscode-appwrite.setActiveProject", title: "Set active", arguments: [this] };
}
this.sdk = createAppwriteSdk(project);
}
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;
}

7
src/tree/projects/ProjectsTreeItemProvider.ts
View file

@ -1,5 +1,6 @@
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> {
@ -25,7 +26,11 @@ export class ProjectsTreeItemProvider implements vscode.TreeDataProvider<vscode.
return element;
}
async getChildren(_element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
async getChildren(element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
if (element instanceof AppwriteTreeItemBase) {
return element.getChildren?.() ?? [];
}
const configs = await getAppwriteProjects();
if (configs === undefined || configs.length === 0) {
return [];

31
src/tree/storage/StorageTreeItemProvider.ts
View file

@ -1,30 +1,37 @@
import * as vscode from "vscode";
import { storageClient } from "../../client";
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 { FileTreeItem } from "./FileTreeItem";
export class StorageTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
private _onDidChangeTreeData: vscode.EventEmitter<vscode.TreeItem | undefined | void> = new vscode.EventEmitter<
vscode.TreeItem | undefined | void
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
>();
readonly onDidChangeTreeData: vscode.Event<vscode.TreeItem | undefined | void> = this._onDidChangeTreeData.event;
readonly onDidChangeTreeData: Event<TreeItem | undefined | void> = this._onDidChangeTreeData.event;
refresh(): void {
this._onDidChangeTreeData.fire();
}
getTreeItem(element: vscode.TreeItem): vscode.TreeItem {
getTreeItem(element: TreeItem): TreeItem {
return element;
}
async getChildren(_element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
if (storageClient === undefined) {
return [];
}
collapsibleState = TreeItemCollapsibleState.Collapsed;
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 vscode.TreeItem("No files found");
const noStorage = new TreeItem("No files found");
return [noStorage];
}
return files.files.map((file) => new FileTreeItem(file));

45
src/tree/users/UserTreeItem.ts
View file

@ -1,14 +1,53 @@
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 vscode.TreeItem {
constructor(public readonly user: User) {
super(user.email);
export class UserTreeItem extends AppwriteTreeItemBase<UserTreeItemProvider> {
constructor(parent: UserTreeItemProvider, public readonly user: User) {
super(parent, 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";

57
src/tree/users/UserTreeItemProvider.ts
View file

@ -1,15 +1,18 @@
import * as vscode from "vscode";
import { client } from "../../client";
import AppwriteCall from "../../utils/AppwriteCall";
import { User, UsersList } from "../../appwrite";
import { ThemeIcon } from "vscode";
import { UserPrefsTreeItem } from "./properties/UserPrefsTreeItem";
import { ChildTreeItem } from "../ChildTreeItem";
import { Client, User, UsersList } from "../../appwrite";
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 implements vscode.TreeDataProvider<vscode.TreeItem> {
export class UserTreeItemProvider extends AppwriteTreeItemBase<ProjectTreeItem> {
constructor(parent: ProjectTreeItem, private readonly sdk: Client) {
super(parent, "Users");
this.iconPath = new vscode.ThemeIcon('account');
}
private _onDidChangeTreeData: vscode.EventEmitter<UserTreeItem | undefined | void> = new vscode.EventEmitter<
UserTreeItem | undefined | void
>();
@ -24,48 +27,14 @@ export class UserTreeItemProvider implements vscode.TreeDataProvider<vscode.Tree
return element;
}
async getChildren(element?: UserTreeItem): Promise<vscode.TreeItem[]> {
if (client === undefined) {
return Promise.resolve([]);
}
collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
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);
}
async getChildren(): Promise<vscode.TreeItem[]> {
const usersSdk = new sdk.Users(client);
const usersSdk = new sdk.Users(this.sdk);
const usersList = await AppwriteCall<UsersList, UsersList>(usersSdk.list());
if (usersList) {
const userTreeItems = usersList.users.map((user: User) => new UserTreeItem(user)) ?? [];
const userTreeItems = usersList.users.map((user: User) => new UserTreeItem(this, user)) ?? [];
const headerItem: vscode.TreeItem = {
label: `Total users: ${usersList.sum}`,
};