Update bug.yaml

2021-08-18 17:41:48 -07:00 · 2021-08-18 17:41:22 -07:00 · 2021-08-18 17:40:59 -07:00 · 2021-08-18 17:25:27 -07:00 · 2021-06-17 16:55:43 -07:00 · 2021-06-17 16:49:08 -07:00
77 changed files with 3003 additions and 4135 deletions
--- a/.github/ISSUE_TEMPLATE/bug.yaml
+++ b/.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
--- a/.github/workflows/ciBuild.yml
+++ b/.github/workflows/ciBuild.yml
@ -26,4 +26,10 @@ jobs:
      with:
        node-version: ${{ matrix.node-version }}
    - run: npm ci
-    - run: npm run package
+    - run: npx vsce package
+
+    - uses: actions/upload-artifact@v2
+      with:
+        name: vsix
+        path: '*.vsix'
+        if-no-files-found: error # 'warn' or 'ignore' are also available, defaults to `warn`
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -5,6 +5,48 @@ All notable changes to the "vscode-appwrite" extension will be documented in thi
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.

 ## [Unreleased]
+
+## [0.1.3] - 2021-6-17
+## Added
+- New feature! JSON strings inside documents will now be automatically formatted as JSON when viewing documents. You can turn this feature off via the `appwrite.formatJsonStrings` setting.
+
+## [0.1.2] - 2021-6-03
+## Added
+- Ability to set the `list`, `default` and `array` properties when creating a new collection. | [Issue #20](https://github.com/streamlux/vscode-appwrite/issues/20) | [PR #21](https://github.com/streamlux/vscode-appwrite/pull/21) | Thanks [@Maatteogekko](https://github.com/Maatteogekko)!
+
+## [0.1.1] - 2021-5-31
+## Added
+- You can now easily create function tags from multiple places in the extension. [PR #19](https://github.com/streamlux/vscode-appwrite/pull/19)
+
+## Fixed
+- Fixed an error when deleting a user. [Issue #17](https://github.com/streamlux/vscode-appwrite/issues/17) [PR #18](https://github.com/streamlux/vscode-appwrite/pull/18) Thanks [@aadarshadhakalg](https://github.com/aadarshadhakalg)!
+
+## [0.1.0] - 2021-5-29
+
+## Functions!
+### Added
+- Ability to create and delete Appwrite functions
+- Edit function settings
+- View, and delete tags (creating tags is broken currently)
+- Create and view function executions
+- View execution output and errors
+
+## [0.0.9] - 2021-5-21
+- Remove temporary fix for Appwrite https://github.com/appwrite/appwrite/issues/1171. Upstream issue was resolved.
+
+## [0.0.8] - 2021-5-21
+- Temp fix for Appwrite https://github.com/appwrite/appwrite/issues/1171
+
+## [0.0.7] - 2021-5-14
+### Fixed
+- Fixed a bug where the password validation for creating a new user did not follow the Appwrite spec. [Issue](https://github.com/streamlux/vscode-appwrite/issues/11)
+- Show nicer message when Appwrite project can't be found. [Issue](https://github.com/streamlux/vscode-appwrite/pull/14)
+
+## [0.0.6] - 2021-4-30
+### Fixed
+- Fixed a bug where the extension could not connect to Appwrite instances over localhost beacuse of self-signed certificates.
+
+## [0.0.5] - 2021-4-30
 ### Fixed
 - Sometimes views would not refresh after adding/removing a project [PR](https://github.com/streamlux/vscode-appwrite/pull/7)

--- a/README.md
+++ b/README.md
@ -1,13 +1,11 @@
+![Cover image](media/readmeCoverImage.png)
+
 # Appwrite for Visual Studio Code

-<!-- region exclude-from-marketplace -->
+Use the Appwrite extension to quickly monitor, manage, and interact with your Appwrite instance directly from VS Code.

 [![Version](https://vsmarketplacebadge.apphb.com/version/streamlux.vscode-appwrite.svg)](https://marketplace.visualstudio.com/items?itemName=streamlux.vscode-appwrite) [![Installs](https://vsmarketplacebadge.apphb.com/installs-short/streamlux.vscode-appwrite.svg)](https://marketplace.visualstudio.com/items?itemName=streamlux.vscode-appwrite)

-<!-- endregion exclude-from-marketplace -->
-
-Use the Appwrite extension to quickly monitor, manage, and interact with your Appwrite instance directly from VS Code.
-
 ## What is Appwrite?

 From [appwrite.io](https://appwrite.io)
@ -20,7 +18,15 @@ From [appwrite.io](https://appwrite.io)

 ### Connect to multiple Appwrite projects

-![Mutliple projects](media/features/projects/projectsView1.gif)
+<img src="media/features/projects/projectsView1.gif" height="600">
+
+### Creating function tags with ease!
+
+![Functions feature](media/features/functions/CreateTag.gif)
+
+### Create and manage Appwrite cloud functions, upload tags, and view function output
+
+<img src="media/features/functions/functionsOverview.png" height="500">

 ### View database documents right inside VS Code.

@ -58,6 +64,7 @@ After connecting to an Appwrite project, your `appwrite.projects` setting will c
            "endpoint": "https://[Domain]/v1",
            "projectId": "[Project ID]",
            "secret": "API key with all scopes",
+            "selfSigned": "boolean", // set to true if you're connecting to Appwrite over localhost
            "nickname": "My project"
 }
 ```
--- a/media/features/functions/CreateTag.gif
+++ b/media/features/functions/CreateTag.gif
--- a/media/features/functions/functionsOverview.png
+++ b/media/features/functions/functionsOverview.png
--- a/media/readmeCoverImage.png
+++ b/media/readmeCoverImage.png
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -2,7 +2,7 @@
    "name": "vscode-appwrite",
    "displayName": "Appwrite",
    "description": "Manage your Appwrite resources right from VS Code!",
-    "version": "0.0.4",
+    "version": "0.1.3",
    "engines": {
        "vscode": "^1.55.0"
    },
@ -30,7 +30,9 @@
        "onView:Users",
        "onView:Database",
        "onView:Health",
-        "onCommand:vscode-appwrite.AddProject"
+        "onView:Functions",
+        "onCommand:vscode-appwrite.AddProject",
+        "onCommand:vscode-appwrite.CreateTag"
    ],
    "main": "./dist/extension.js",
    "contributes": {
@ -38,156 +40,305 @@
            {
                "command": "vscode-appwrite.Connect",
                "title": "Connect to Appwrite",
-                "category": ""
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.CreateUser",
                "title": "Create user",
-                "icon": "$(add)"
+                "icon": "$(add)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.DeleteUser",
                "title": "Delete user",
-                "icon": "$(trash)"
+                "icon": "$(trash)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.GetUserLogs",
                "title": "Get user logs",
-                "icon": "$(output)"
+                "icon": "$(output)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.openUserInConsole",
                "title": "View user in Appwrite console",
-                "icon": "$(link-external)"
+                "icon": "$(link-external)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.viewUserPrefs",
                "title": "View user preferences",
-                "icon": "$(json)"
+                "icon": "$(json)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.refreshEntry",
                "title": "Refresh",
-                "icon": "$(refresh)"
+                "icon": "$(refresh)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.copyUserId",
                "title": "Copy user ID",
-                "icon": "$(clippy)"
+                "icon": "$(clippy)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.copyUserEmail",
                "title": "Copy user email",
-                "icon": "$(clippy)"
+                "icon": "$(clippy)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.refreshUsersList",
                "title": "Refresh users list",
-                "icon": "$(refresh)"
+                "icon": "$(refresh)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.OpenUsersDocumentation",
                "title": "Open documentation",
-                "icon": "$(book)"
+                "icon": "$(book)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.OpenDatabaseDocumentation",
                "title": "Open documentation",
-                "icon": "$(book)"
+                "icon": "$(book)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.viewDocumentAsJson",
-                "title": "View as JSON"
+                "title": "View as JSON",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.viewCollectionAsJson",
-                "title": "View collection as JSON"
+                "title": "View collection as JSON",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.refreshCollection",
                "title": "Refresh",
-                "icon": "$(refresh)"
+                "icon": "$(refresh)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.createRule",
                "title": "Create collection rule",
-                "icon": "$(add)"
+                "icon": "$(add)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.removeRule",
-                "title": "Remove collection rule"
+                "title": "Remove collection rule",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.deleteDocument",
-                "title": "Delete document"
+                "title": "Delete document",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.deleteCollection",
-                "title": "Delete collection"
+                "title": "Delete collection",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.refreshCollectionsList",
                "title": "Refresh",
-                "icon": "$(refresh)"
+                "icon": "$(refresh)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.createCollection",
                "title": "Create collection",
-                "icon": "$(add)"
+                "icon": "$(add)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.createPermission",
                "title": "Create permission",
-                "icon": "$(add)"
+                "icon": "$(add)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.deletePermission",
                "title": "Delete permission",
-                "icon": "$(trash)"
+                "icon": "$(trash)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.editPermission",
                "title": "Edit permission",
-                "icon": "$(edit)"
+                "icon": "$(edit)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.refreshHealth",
                "title": "Refresh health",
-                "icon": "$(refresh)"
+                "icon": "$(refresh)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.openHealthDocumentation",
                "title": "Open health documentation",
-                "icon": "$(book)"
+                "icon": "$(book)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.refreshStorage",
                "title": "Refresh storage",
-                "icon": "$(refresh)"
+                "icon": "$(refresh)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.openStorageDocumentation",
                "title": "Open storage documentation",
-                "icon": "$(book)"
+                "icon": "$(book)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.addProject",
                "title": "Add Appwrite project",
-                "icon": "$(plus)"
+                "icon": "$(plus)",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.setActiveProject",
-                "title": "Set as active"
+                "title": "Set as active",
+                "category": "Appwrite"
            },
            {
                "command": "vscode-appwrite.refreshProjects",
                "title": "Refresh projects",
+                "icon": "$(refresh)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.refreshFunctions",
+                "title": "Refresh functions",
+                "icon": "$(refresh)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.refreshFunctions",
+                "title": "Refresh functions",
                "icon": "$(refresh)"
            },
            {
                "command": "vscode-appwrite.removeProject",
                "title": "Remove project",
-                "icon": "$(trash)"
+                "icon": "$(trash)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.CreateTag",
+                "title": "Create function tag",
+                "icon": "$(cloud-upload)",
+                "shortTitle": "Create function tag",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.deleteTag",
+                "title": "Delete tag",
+                "icon": "$(trash)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.CreateExecution",
+                "title": "Execute",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.activateTag",
+                "title": "Activate",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.editValue",
+                "title": "Edit",
+                "icon": "$(edit)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.deleteFunction",
+                "title": "Delete",
+                "icon": "$(trash)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.openFunctionsDocumentation",
+                "title": "Open functions documentation",
+                "icon": "$(book)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.createFunction",
+                "title": "Create function",
+                "icon": "$(add)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.createFunctionVar",
+                "title": "Create variable",
+                "icon": "$(add)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.deleteFunctionVar",
+                "title": "Delete variable",
+                "icon": "$(trash)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.viewExecutionOutput",
+                "title": "View execution stdout",
+                "enablement": "viewItem =~ /^((execution|execution_outputOnly))$/",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.viewExecutionErrors",
+                "title": "View execution stderr",
+                "enablement": "viewItem =~ /^((execution|execution_errorOnly))$/",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.copyExecutionOutput",
+                "title": "Copy execution stdout",
+                "enablement": "viewItem =~ /^((execution|execution_outputOnly))$/",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.copyExecutionErrors",
+                "title": "Copy execution stderr",
+                "enablement": "viewItem =~ /^((execution|execution_errorOnly))$/",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.openExecutionsInBrowser",
+                "title": "View executions in browser",
+                "enablement": "viewItem =~ /^(executions)$/",
+                "icon": "$(link-external)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.openFunctionTagsInBrowser",
+                "title": "Open function tags in browser",
+                "icon": "$(link-external)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.openFunctionSettingsInBrowser",
+                "title": "Open function settings in browser",
+                "icon": "$(link-external)",
+                "category": "Appwrite"
+            },
+            {
+                "command": "vscode-appwrite.viewMore",
+                "title": "View more",
+                "category": "Appwrite"
            }
        ],
        "views": {
@ -211,6 +362,10 @@
                {
                    "id": "Projects",
                    "name": "Projects"
+                },
+                {
+                    "id": "Functions",
+                    "name": "Functions (Preview)"
                }
            ]
        },
@ -276,14 +431,24 @@
                    "when": "view == Storage",
                    "group": "navigation"
                },
+                {
+                    "command": "vscode-appwrite.openFunctionsDocumentation",
+                    "when": "view == Functions",
+                    "group": "navigation"
+                },
                {
                    "command": "vscode-appwrite.refreshProjects",
                    "when": "view == Projects",
                    "group": "navigation"
                },
                {
-                    "command": "vscode-appwrite.addProject",
-                    "when": "view == Projects",
+                    "command": "vscode-appwrite.refreshFunctions",
+                    "when": "view == Functions",
+                    "group": "navigation"
+                },
+                {
+                    "command": "vscode-appwrite.createFunction",
+                    "when": "view == Functions",
                    "group": "navigation"
                }
            ],
@ -383,9 +548,91 @@
                {
                    "command": "vscode-appwrite.removeProject",
                    "when": "viewItem =~ /(appwriteProject)/"
+                },
+                {
+                    "command": "vscode-appwrite.CreateExecution",
+                    "when": "viewItem =~ /^(function)$/",
+                    "group": "inline"
+                },
+                {
+                    "command": "vscode-appwrite.activateTag",
+                    "when": "viewItem =~ /^(tag)$/",
+                    "group": "inline"
+                },
+                {
+                    "command": "vscode-appwrite.editValue",
+                    "when": "viewItem =~ /^(editable)/",
+                    "group": "inline"
+                },
+                {
+                    "command": "vscode-appwrite.deleteFunction",
+                    "when": "viewItem =~ /^(function)$/"
+                },
+                {
+                    "command": "vscode-appwrite.deleteFunctionVar",
+                    "when": "viewItem =~ /(var)$/"
+                },
+                {
+                    "command": "vscode-appwrite.createFunctionVar",
+                    "when": "viewItem =~ /^(vars)$/",
+                    "group": "inline"
+                },
+                {
+                    "command": "vscode-appwrite.deleteTag",
+                    "when": "viewItem =~ /^(tag)$/"
+                },
+                {
+                    "command": "vscode-appwrite.viewExecutionErrors",
+                    "when": "viewItem =~ /^execution[^s]*$/",
+                    "group": "view@1"
+                },
+                {
+                    "command": "vscode-appwrite.viewExecutionOutput",
+                    "when": "viewItem =~ /^execution[^s]*$/",
+                    "group": "view@1"
+                },
+                {
+                    "command": "vscode-appwrite.copyExecutionErrors",
+                    "when": "viewItem =~ /^execution[^s]*$/",
+                    "group": "copy@2"
+                },
+                {
+                    "command": "vscode-appwrite.copyExecutionOutput",
+                    "when": "viewItem =~ /^execution[^s]*$/",
+                    "group": "copy@2"
+                },
+                {
+                    "command": "vscode-appwrite.openExecutionsInBrowser",
+                    "when": "viewItem =~ /^executions$/",
+                    "group": "inline"
+                },
+                {
+                    "command": "vscode-appwrite.openFunctionTagsInBrowser",
+                    "when": "viewItem =~ /^tags$/",
+                    "group": "inline"
+                },
+                {
+                    "command": "vscode-appwrite.openFunctionSettingsInBrowser",
+                    "when": "viewItem =~ /^functionSettings$/",
+                    "group": "inline"
+                },
+                {
+                    "command": "vscode-appwrite.CreateTag",
+                    "when": "viewItem =~ /^tags$/",
+                    "group": "inline"
+                }
+            ],
+            "explorer/context": [
+                {
+                    "command": "vscode-appwrite.CreateTag",
+                    "when": "explorerResourceIsFolder == true",
+                    "group": "appwrite@1"
                }
            ],
            "commandPalette": [
+                {
+                    "command": "vscode-appwrite.CreateTag"
+                },
                {
                    "command": "vscode-appwrite.Connect"
                },
@ -479,6 +726,11 @@
                    "type": "string",
                    "default": "",
                    "markdownDescription": "Project id of the active project, see [docs](https://github.com/streamlux/vscode-appwrite/) for more information."
+                },
+                "appwrite.formatJsonStrings": {
+                    "type": "boolean",
+                    "default": true,
+                    "markdownDescription": "Format JSON strings when viewing documents"
                }
            }
        }
@ -499,6 +751,7 @@
        "@types/glob": "^7.1.3",
        "@types/mocha": "^8.0.4",
        "@types/node": "^12.11.7",
+        "@types/tar": "^4.0.4",
        "@types/vscode": "^1.55.0",
        "@typescript-eslint/eslint-plugin": "^4.14.1",
        "@typescript-eslint/parser": "^4.14.1",
@ -507,13 +760,17 @@
        "mocha": "^8.2.1",
        "ts-loader": "^8.0.14",
        "typescript": "^4.1.3",
+        "vsce": "^1.88.0",
        "vscode-test": "^1.5.0",
        "webpack": "^5.19.0",
        "webpack-cli": "^4.4.0"
    },
    "dependencies": {
+        "cron-validate": "^1.4.3",
+        "cronstrue": "^1.113.0",
        "dayjs": "^1.10.4",
        "fs-extra": "^9.1.0",
-        "node-appwrite": "^2.1.0"
+        "node-appwrite": "^2.2.3",
+        "tar": "^6.1.0"
    }
 }
--- a/src/appwrite.d.ts
+++ b/src/appwrite.d.ts
@ -1,3 +1,6 @@
+import { ReadStream } from 'fs';
+import { Stream } from 'node:stream';
+
 export type Token = {
    /**
     * Token ID.
@ -243,18 +246,18 @@ type Membership = {
 };

 export type FilesList = {
-  sum: number;
-  files: File[];
+    sum: number;
+    files: File[];
 };

 export type File = {
-  '$id': string;
-  '$permissions': Permissions;
-  name: string;
-  dateCreated: number;
-  signature: string;
-  mimeType: string;
-  sizeOriginal: number;
+    $id: string;
+    $permissions: Permissions;
+    name: string;
+    dateCreated: number;
+    signature: string;
+    mimeType: string;
+    sizeOriginal: number;
 };

 export type Collection = {
@ -266,14 +269,14 @@ export type Collection = {
    rules: Rule[];
 };

-export type CreatedCollection = Partial<Collection> & Pick<Collection, 'name'>;
+export type CreatedCollection = Partial<Collection> & Pick<Collection, "name">;

 export type CollectionsList = {
    sum: number;
    collections: Collection[];
 };

-export type CreatedRule = Omit<Rule, '$id' | '$collection' | 'default' | 'list'>;
+export type CreatedRule = Omit<Rule, "$id" | "$collection">;

 export type Rule = {
    $id: string;
@ -281,13 +284,13 @@ export type Rule = {
    type: string;
    key: string;
    label: string;
-    default: string;
-    array: boolean;
+    default?: any;
    required: boolean;
-    list: string[];
+    array: boolean;
+    list?: string[];
 };

-interface Permissions {
+export type Permissions = {
    read: string[];
    write: string[];
 }
@ -299,9 +302,10 @@ export type Client = {
    setProject: (projectId: string) => Client;
    // Your secret API key
    setKey: (key: string) => Client;
+    setSelfSigned: (value: boolean) => void;
 };
 export type UsersClient = {
-    deleteUser: (id: string) => Promise<any>;
+    delete: (id: string) => Promise<any>;
    deleteSessions: (id: string) => Promise<any>;
    create: (email: string, password: string, name?: string) => Promise<any>;
    getLogs: (id: string) => Promise<Log[]>;
@ -355,9 +359,88 @@ export type AppwriteHealth = {
 };

 export type StorageClient = {
-    createFile: (file: any, read: string[], write: string[]) => Promise<any>;
+    createFile: (file: any, read?: string[], write?: string[]) => Promise<any>;
    listFiles: () => Promise<any>;
    getFile: (fileId: string) => Promise<any>;
+};
+
+type Vars = Record<string, any>;
+
+export type Function = {
+  '$id': string;
+  '$permissions': Permissions;
+  name: string;
+  dateCreated: number;
+  dateUpdated: number;
+  status: string;
+  env: string;
+  tag: string;
+  vars: Vars;
+  events: string[];
+  schedule: string;
+  scheduleNext: number;
+  schedulePrevious: number;
+  timeout: number;
+}
+
+export type FunctionsList = {
+    sum: number;
+    functions: Function[];
+}
+
+export type Tag = {
+  '$id': string;
+  functionId: string;
+  dateCreated: number;
+  command: string;
+  size: string;
+};
+
+export type TagList = {
+    sum: number;
+    tags: Tag[];
+}
+
+export type ExecutionStatus = "waiting" | "processing" | "completed" | "failed";
+
+export type Execution = {
+  '$id': string;
+  functionId: string;
+  dateCreated: number;
+  trigger: string;
+  status: ExecutionStatus;
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  time: number;
+};
+
+export type ExecutionList = {
+    sum: number;
+    executions: Execution[];
+};
+
+export type Search = {
+    search?: string;
+    limit?: number;
+    offset?: number;
+    orderType?: 'ASC' | 'DESC';
+};
+
+export type FunctionsClient = {
+    create: (name: string, execute: string[], env: string, vars?: Vars, events?: string[], schedule?: string, timeout?: number) => Promise<any>;
+    list: (search?: string, offset?: number, limit?: number, orderType?: 'ASC' | 'DESC') => Promise<any>;
+    get: (functionId: string) => Promise<any>;
+    update: (functionId: string, name: string, execute: string[], vars?: Vars, events?: string[], schedule?: string, timeout?: number) => Promise<any>;
+    updateTag: (functionId: string, tagId: string) => Promise<any>;
+    delete: (functionId: string) => Promise<any>;
+    createTag: (id: string, command: string, code: ReadStream) => Promise<any>;
+    listTags: (id: string, search?: string, limit?: number, offset?: number, orderType?: 'ASC' | 'DESC') => Promise<any>;
+    getTag: (functionId: string, tagId: string) => Promise<any>;
+    deleteTag: (functionId: string, tagId: string) => Promise<any>;
+    createExecution: (functionId: string, data?: string) => Promise<any>;
+    listExecutions: (functionId: string, search?: string, limit?: number, offset?: number, orderType?: 'ASC' | 'DESC') => Promise<any>;
+    getExecution: (functionId: string, executionId: string) => Promise<any>;
 }

 export type SDK = {
@ -367,4 +450,5 @@ export type SDK = {
    Health: new (client: Client) => HealthClient;
    Database: new (client: Client) => DatabaseClient;
    Storage: new (client: Client) => StorageClient;
+    Functions: new (client: Client) => FunctionsClient;
 };
--- a/src/appwrite/Functions.ts
+++ b/src/appwrite/Functions.ts
@ -0,0 +1,52 @@
+import { Client, Execution, ExecutionList, FunctionsClient, FunctionsList, Tag, TagList, Vars } from "../appwrite";
+import { AppwriteSDK } from '../constants';
+import AppwriteCall from '../utils/AppwriteCall';
+import { ReadStream } from 'node:fs';
+
+export class Functions {
+    public readonly functions: FunctionsClient;
+
+    constructor(client: Client) {
+        this.functions = new AppwriteSDK.Functions(client);
+    }
+
+    public async create(name: string, execute: string[], env: string, vars?: Vars, events?: string[], schedule?: string, timeout?: number): Promise<any> {
+        return await AppwriteCall(this.functions.create(name, execute, env, vars, events, schedule, timeout));
+    }
+    public async list(search?: string, offset?: number, limit?: number, orderType?: 'ASC' | 'DESC'): Promise<FunctionsList | undefined> {
+        return await AppwriteCall(this.functions.list(search, offset, limit, orderType));
+    }
+    public async get(functionId: string): Promise<any> {
+        return await AppwriteCall(this.functions.get(functionId));
+    }
+    public async update(functionId: string, name: string, execute: string[], vars?: Vars, events?: string[], schedule?: string, timeout?: number): Promise<any> {
+        return await AppwriteCall(this.functions.update(functionId, name, execute, vars, events, schedule, timeout));
+    }
+    public async updateTag(functionId: string, tagId: string): Promise<any> {
+        return await AppwriteCall(this.functions.updateTag(functionId, tagId));
+    }
+    public async delete(functionId: string): Promise<void> {
+        return await AppwriteCall(this.functions.delete(functionId));
+    }
+    public async createTag(functionId: string, command: string, code: ReadStream): Promise<Tag | undefined> {
+        return await AppwriteCall(this.functions.createTag(functionId, command, code));
+    }
+    public async listTags(id: string, search?: string, limit?: number, offset?: number, orderType?: 'ASC' | 'DESC'): Promise<TagList | undefined> {
+        return await AppwriteCall<TagList>(this.functions.listTags(id, search, offset, limit, orderType));
+    }
+    public async getTag(functionId: string, tagId: string): Promise<any> {
+        return await AppwriteCall(this.functions.getTag(functionId, tagId));
+    }
+    public async deleteTag(functionId: string, tagId: string): Promise<void> {
+        return await AppwriteCall(this.functions.deleteTag(functionId, tagId));
+    }
+    public async createExecution(functionId: string, data?: string): Promise<Execution | undefined> {
+        return await AppwriteCall(this.functions.createExecution(functionId, data));
+    }
+    public async listExecutions(functionId: string, search?: string, limit?: number, offset?: number, orderType?: 'ASC' | 'DESC'): Promise<ExecutionList | undefined> {
+        return await AppwriteCall(this.functions.listExecutions(functionId, search, limit, offset, orderType));
+    }
+    public async getExecution(functionId: string, executionId: string): Promise<Execution | undefined> {
+        return await AppwriteCall(this.functions.getExecution(functionId, executionId));
+    }
+}
--- a/src/appwrite/Health.ts
+++ b/src/appwrite/Health.ts
@ -11,7 +11,7 @@ export class Health {
    /**
     * @returns The health of all Appwrite services.
     */
-    public async checkup(): Promise<AppwriteHealth> {
+    public async checkup(): Promise<Partial<AppwriteHealth>> {
        return {
            HTTP: await this.health.get(),
            DB: await this.health.getDB(),
--- a/src/appwrite/Storage.ts
+++ b/src/appwrite/Storage.ts
@ -1,3 +1,4 @@
+import { ReadStream } from 'node:fs';
 import { Client, FilesList, StorageClient } from "../appwrite";
 import { AppwriteSDK } from '../constants';
 import AppwriteCall from "../utils/AppwriteCall";
@ -12,4 +13,8 @@ export class Storage {
    public async listFiles(): Promise<FilesList | undefined> {
        return await AppwriteCall(this.storage.listFiles());
    }
+
+    public async createFile(file: ReadStream): Promise<void> {
+        return await AppwriteCall(this.storage.createFile(file));
+    }
 }
--- a/src/appwrite/Users.ts
+++ b/src/appwrite/Users.ts
@ -16,7 +16,7 @@ export class Users {
    }

    public async delete(userId: string): Promise<void> {
-        await AppwriteCall(this.users.deleteUser(userId), () => {
+        await AppwriteCall(this.users.delete(userId), () => {
            window.showInformationMessage(`Deleted user with id: ${userId}.`);
        });
    }
--- a/src/client.ts
+++ b/src/client.ts
@ -1,5 +1,6 @@
 import { Client } from "./appwrite";
 import { Database } from "./appwrite/Database";
+import { Functions } from './appwrite/Functions';
 import { Health } from "./appwrite/Health";
 import { Storage } from "./appwrite/Storage";
 import { Users } from "./appwrite/Users";
@ -12,16 +13,19 @@ export let usersClient: Users | undefined;
 export let healthClient: Health | undefined;
 export let databaseClient: Database | undefined;
 export let storageClient: Storage | undefined;
+export let functionsClient: Functions | undefined;

-function initAppwriteClient({ endpoint, projectId, secret }: AppwriteProjectConfiguration) {
+
+function initAppwriteClient({ endpoint, projectId, secret, selfSigned }: AppwriteProjectConfiguration) {
    client = new AppwriteSDK.Client();
    clientConfig = { endpoint, projectId, secret };
-    client.setEndpoint(endpoint).setProject(projectId).setKey(secret);
+    client.setEndpoint(endpoint).setProject(projectId).setKey(secret).setSelfSigned(selfSigned);

    usersClient = new Users(client);
    healthClient = new Health(client);
    databaseClient = new Database(client);
    storageClient = new Storage(client);
+    functionsClient = new Functions(client);

    return client;
 }
@ -36,4 +40,5 @@ export function createAppwriteClient(config?: AppwriteProjectConfiguration): voi
    healthClient = undefined;
    databaseClient = undefined;
    storageClient = undefined;
+    functionsClient = undefined;
 }
--- a/src/commands/common/editValue.ts
+++ b/src/commands/common/editValue.ts
@ -0,0 +1,9 @@
+import { EditableTreeItem } from '../../tree/common/editable/SimpleEditableTreeItem';
+
+export async function editValue(treeItem: EditableTreeItem): Promise<void> {
+    if (treeItem === undefined) {
+        return;
+    }
+
+    await treeItem.prompt();
+}
--- a/src/commands/common/viewMore.ts
+++ b/src/commands/common/viewMore.ts
@ -0,0 +1,5 @@
+import { AppwriteTreeItemBase } from '../../ui/AppwriteTreeItemBase';
+
+export async function viewMore(treeItem: AppwriteTreeItemBase<any>): Promise<void> {
+    await treeItem.viewMore();
+}
--- a/src/commands/database/createRule.ts
+++ b/src/commands/database/createRule.ts
@ -10,15 +10,13 @@ export async function createRule(rulesTreeItem: RulesTreeItem): Promise<void> {
        return;
    }

-    const ruleContext = await createRuleWizard();
    const collection = rulesTreeItem.parent.collection;
+    const ruleContext = await createRuleWizard(collection);

    if (ruleContext) {
        const newRule: CreatedRule = {
            ...ruleContext,
            type: ruleContext.type,
-            required: true,
-            array: false,
        };

        databaseClient.createRule(collection, newRule);
--- a/src/commands/database/openDocument.ts
+++ b/src/commands/database/openDocument.ts
@ -1,8 +1,30 @@
+import { workspace } from "vscode";
 import { DocumentTreeItem } from "../../tree/database/DocumentTreeItem";
 import { openReadOnlyJson } from "../../ui/openReadonlyContent";

+function parseJSONString(str: string): { valid: boolean; value: any } {
+    try {
+        return { value: JSON.parse(str), valid: true };
+    } catch (e) {
+        return { value: str, valid: false };
+    }
+}
+
 export async function viewDocumentAsJson(documentTreeItem: DocumentTreeItem): Promise<void> {
-    const documentId = documentTreeItem.document["$id"];
+    const document = documentTreeItem.document;
+    const documentId = document["$id"];
+
+    const formatJsonStrings = workspace.getConfiguration("appwrite").get<Boolean>("formatJsonStrings");
+
+    if (formatJsonStrings) {
+        Object.entries(document).forEach(([key, value]) => {
+            if (typeof value === "string") {
+                const result = parseJSONString(value);
+                document[key] = result.value;
+            }
+        });
+    }
+
    await openReadOnlyJson(
        {
            label: documentId,
--- a/src/commands/functions/activateTag.ts
+++ b/src/commands/functions/activateTag.ts
@ -0,0 +1,8 @@
+import { Tag } from '../../appwrite';
+import { functionsClient } from '../../client';
+import { TagTreeItem } from '../../tree/functions/tags/TagTreeItem';
+
+export async function activateTag(tagItem: TagTreeItem | Tag): Promise<void> {
+    const tag = tagItem instanceof TagTreeItem ? tagItem.tag : tagItem;
+    await functionsClient?.updateTag(tag.functionId, tag.$id);
+}
--- a/src/commands/functions/copyExecutionErrors.ts
+++ b/src/commands/functions/copyExecutionErrors.ts
@ -0,0 +1,11 @@
+import { env } from 'vscode';
+import { ExecutionTreeItem } from "../../tree/functions/executions/ExecutionTreeItem";
+
+export async function copyExecutionErrors(executionItem: ExecutionTreeItem): Promise<void> {
+    if (executionItem === undefined) {
+        return;
+    }
+
+    const execution = executionItem.execution;
+    env.clipboard.writeText(execution.stderr);
+}
--- a/src/commands/functions/copyExecutionOutput.ts
+++ b/src/commands/functions/copyExecutionOutput.ts
@ -0,0 +1,11 @@
+import { env } from 'vscode';
+import { ExecutionTreeItem } from "../../tree/functions/executions/ExecutionTreeItem";
+
+export async function copyExecutionOutput(executionItem: ExecutionTreeItem): Promise<void> {
+    if (executionItem === undefined) {
+        return;
+    }
+
+    const execution = executionItem.execution;
+    env.clipboard.writeText(execution.stdout);
+}
--- a/src/commands/functions/createExecution.ts
+++ b/src/commands/functions/createExecution.ts
@ -0,0 +1,57 @@
+import { window } from 'vscode';
+import { Execution } from '../../appwrite';
+import { functionsClient } from '../../client';
+import { ext } from '../../extensionVariables';
+import { FunctionTreeItem } from '../../tree/functions/FunctionTreeItem';
+import { sleep } from '../../utils/sleep';
+import { viewExecutionErrors } from './viewExecutionErrors';
+import { viewExecutionOutput } from './viewExecutionOutput';
+
+export async function createExecution(functionTreeItem: FunctionTreeItem): Promise<void> {
+    const func = functionTreeItem.func;
+    await executeFunction(func.$id);
+}
+
+export async function executeFunction(functionId: string): Promise<void> {
+    ext.outputChannel.appendLog(`Creating execution for function with ID: ${functionId}`);
+    let execution = await functionsClient?.createExecution(functionId);
+    ext.outputChannel.appendLog(JSON.stringify(execution, null, 2));
+    await ext.tree?.functions?.refresh();
+
+    if (execution === undefined) {
+        return;
+    }
+
+    execution = await waitForExecution(execution);
+    ext.tree?.functions?.refresh();
+
+    if (execution === undefined) {
+        return;
+    }
+
+    const failed = execution.status === "failed";
+    const item = !failed ? "View output" : "View errors";
+    const action = await window.showInformationMessage(`Execution ${failed ? "failed" : "completed"} in ${execution.time.toFixed(2)}s.`, item);
+    if (action === item) {
+        if (item === "View output") {
+            await viewExecutionOutput(execution);
+            return;
+        }
+        await viewExecutionErrors(execution);
+        return;
+    }
+}
+
+async function waitForExecution(execution: Execution | undefined): Promise<Execution | undefined> {
+    if (execution === undefined) {
+        return;
+    }
+    if (execution.status === "processing" || execution.status === "waiting") {
+        await sleep(5000);
+
+        ext.outputChannel.appendLog("Execution still ...");
+        return await waitForExecution(await functionsClient?.getExecution(execution.functionId, execution.$id));
+    }
+
+    return execution;
+}
--- a/src/commands/functions/createFunction.ts
+++ b/src/commands/functions/createFunction.ts
@ -0,0 +1,19 @@
+import { window } from 'vscode';
+import { functionsClient } from '../../client';
+import { appwriteFunctionRuntimes } from '../../constants';
+import { validateFunctionName } from '../../tree/functions/settings/NameTreeItem';
+
+export async function createFunction(): Promise<void> {
+
+    const name = await window.showInputBox({ prompt: 'Function name', validateInput: validateFunctionName });
+    if (name === undefined) {
+        return;
+    }
+
+    const env: string | undefined = await window.showQuickPick(appwriteFunctionRuntimes);
+    if (env === undefined) {
+        return;
+    }
+
+    await functionsClient?.create(name, [], env);
+}
--- a/src/commands/functions/createFunctionVar.ts
+++ b/src/commands/functions/createFunctionVar.ts
@ -0,0 +1,16 @@
+import { functionsClient } from '../../client';
+import { VarsTreeItem } from '../../tree/functions/settings/VarsTreeItem';
+import { keyValuePrompt } from '../../tree/functions/settings/VarTreeItem';
+
+export async function createFunctionVar(treeItem: VarsTreeItem): Promise<void> {
+    if (treeItem === undefined) {
+        return;
+    }
+    const func = treeItem.parent.func;
+    const keyval = await keyValuePrompt();
+    if (keyval) {
+        const newVars = {...func.vars};
+        newVars[keyval.key] = keyval.value;
+        await functionsClient?.update(func.$id, func.name, [], newVars, func.events, func.schedule, func.timeout);
+    }
+}
--- a/src/commands/functions/createTag.ts
+++ b/src/commands/functions/createTag.ts
@ -0,0 +1,164 @@
+import { ProgressLocation, QuickPickItem, Uri, window, workspace } from "vscode";
+import { functionsClient } from "../../client";
+import { getTarReadStream } from "../../utils/tar";
+import { ext } from "../../extensionVariables";
+import * as fs from "fs";
+import { TagsTreeItem } from "../../tree/functions/tags/TagsTreeItem";
+import { selectWorkspaceFolder } from "../../utils/workspace";
+import { ProgressMessage } from "../../utils/types";
+import { Tag } from "../../appwrite";
+import { activateTag } from "./activateTag";
+
+export async function createTag(item?: TagsTreeItem | Uri): Promise<void> {
+    if (item instanceof Uri) {
+        const functions = await functionsClient?.list();
+        if (functions === undefined) {
+            return;
+        }
+        const pick = await window.showQuickPick(
+            functions.functions.map<QuickPickItem>(
+                (func): QuickPickItem => ({ label: func.name, description: func.env, detail: func.$id })
+            ),
+            { placeHolder: "Select a function to create tag" }
+        );
+        if (pick === undefined || pick.detail === undefined) {
+            return;
+        }
+        const tags = await functionsClient?.listTags(pick.detail);
+        let value;
+        if (tags && tags.tags.length > 0) {
+            value = tags.tags[tags.tags.length - 1].command;
+        }
+        const command = await window.showInputBox({ value, prompt: "Command to run your code" });
+        if (command === undefined) {
+            return;
+        }
+        const tag = await window.withProgress(
+            { location: ProgressLocation.Notification, title: "Creating tag..." },
+            async (progress, _token) => {
+                if (pick.detail === undefined) {
+                    return;
+                }
+                return await createTagFromUri(pick.detail, command, item, progress);
+            }
+        );
+        if (tag) {
+            await tagNotification(tag);
+        }
+
+        return;
+    }
+
+    if (item instanceof TagsTreeItem) {
+        const func = item.parent.func;
+        const folder = await selectWorkspaceFolder("Select folder of your function code.");
+        if (folder === undefined || folder === "") {
+            return;
+        }
+        const tags = await functionsClient?.listTags(func.$id);
+        let value;
+        if (tags && tags.tags.length > 0) {
+            value = tags.tags[tags.tags.length - 1].command;
+        }
+        const command = await window.showInputBox({ value, prompt: "Command to run your code" });
+        if (command === undefined) {
+            return;
+        }
+        const tag = await window.withProgress(
+            { location: ProgressLocation.Notification, title: "Creating tag..." },
+            async (progress, _token) => {
+                return await createTagFromUri(func.$id, command, Uri.parse(folder), progress);
+            }
+        );
+
+        if (tag) {
+            await tagNotification(tag);
+            return;
+        }
+    }
+
+    if (item === undefined) {
+        const functions = await functionsClient?.list();
+        if (functions === undefined) {
+            return;
+        }
+        const pick = await window.showQuickPick(
+            functions.functions.map<QuickPickItem>(
+                (func): QuickPickItem => ({ label: func.name, description: func.env, detail: func.$id })
+            ),
+            { placeHolder: "Select a function to create tag" }
+        );
+        if (pick === undefined || pick.detail === undefined) {
+            return;
+        }
+        const funcId = pick.detail;
+        const folder = await selectWorkspaceFolder("Select folder of your function code.");
+        const tags = await functionsClient?.listTags(funcId);
+        let value;
+        if (tags && tags.tags.length > 0) {
+            value = tags.tags[tags.tags.length - 1].command;
+        }
+        const command = await window.showInputBox({ value, prompt: "Command to run your code" });
+        if (command === undefined) {
+            return;
+        }
+        const tag = await window.withProgress(
+            { location: ProgressLocation.Notification, title: "Creating tag..." },
+            async (progress, _token) => {
+                return await createTagFromUri(funcId, command, Uri.parse(folder), progress);
+            }
+        );
+
+        if (tag) {
+            await tagNotification(tag);
+            return;
+        }
+    }
+}
+
+async function createTagFromUri(functionId: string, command: string, uri: Uri, progress: ProgressMessage): Promise<Tag | undefined> {
+    progress.report({ message: "Creating tarball", increment: 10 });
+
+    if (functionsClient === undefined) {
+        return;
+    }
+
+    let tarFilePath;
+    try {
+        tarFilePath = await getTarReadStream(uri);
+    } catch (e) {
+        window.showErrorMessage("Error creating tar file.\n" + e);
+        return;
+    }
+    if (tarFilePath === undefined) {
+        window.showErrorMessage("Failed to create tar file.");
+        ext.outputChannel.appendLog("Failed to create tar file.");
+        return;
+    }
+    // somehow makes the upload work
+    await workspace.fs.readFile(Uri.file(tarFilePath));
+    progress.report({ message: "Uploading tag", increment: 60 });
+    try {
+        return await functionsClient.createTag(functionId, command, fs.createReadStream(tarFilePath));
+    } catch (e) {
+        ext.outputChannel.appendLog("Creating tag error: " + e);
+    }
+}
+
+async function tagNotification(tag: Tag): Promise<void> {
+    ext.tree?.functions?.refresh();
+    if (tag) {
+        const action = await window.showInformationMessage(
+            `Successfully created tag with size ${tag.size}B.`,
+            "Activate tag",
+            "View in console"
+        );
+        if (action === "Activate tag") {
+            await activateTag(tag);
+        }
+        if (action === "View in console") {
+            //
+        }
+        return;
+    }
+}
--- a/src/commands/functions/deleteFunction.ts
+++ b/src/commands/functions/deleteFunction.ts
@ -0,0 +1,9 @@
+import { functionsClient } from '../../client';
+import { FunctionTreeItem } from '../../tree/functions/FunctionTreeItem';
+
+export async function deleteFunction(treeItem: FunctionTreeItem): Promise<void> {
+    if (!treeItem) {
+        return;
+    }
+    await functionsClient?.delete(treeItem.func.$id);
+}
--- a/src/commands/functions/deleteFunctionVar.ts
+++ b/src/commands/functions/deleteFunctionVar.ts
@ -0,0 +1,13 @@
+import { functionsClient } from '../../client';
+import { VarTreeItem } from '../../tree/functions/settings/VarTreeItem';
+
+export async function deleteFunctionVar(treeItem: VarTreeItem): Promise<void> {
+    if (treeItem === undefined) {
+        return;
+    }
+
+    const func = treeItem.func;
+    const newVars = {...func.vars};
+    delete newVars[treeItem.key];
+    await functionsClient?.update(func.$id, func.name, [], newVars, func.events, func.schedule, func.timeout);
+}
--- a/src/commands/functions/deleteTag.ts
+++ b/src/commands/functions/deleteTag.ts
@ -0,0 +1,11 @@
+import { functionsClient } from "../../client";
+import { TagTreeItem } from "../../tree/functions/tags/TagTreeItem";
+
+export async function deleteTag(tagItem: TagTreeItem): Promise<void> {
+    if (tagItem === undefined) {
+        return;
+    }
+
+    const func = tagItem.parent.parent.func;
+    await functionsClient?.deleteTag(func.$id, tagItem.tag.$id);
+}
--- a/src/commands/functions/openExecutionsInBrowser.ts
+++ b/src/commands/functions/openExecutionsInBrowser.ts
@ -0,0 +1,15 @@
+import { clientConfig } from '../../client';
+import { ExecutionsTreeItem } from '../../tree/functions/executions/ExecutionsTreeItem';
+import { openUrl } from '../../utils/openUrl';
+import { getConsoleUrlFromEndpoint } from '../users/openUserInConsole';
+
+export async function openExecutionsInBrowser(treeItem: ExecutionsTreeItem): Promise<void> {
+
+    const func = treeItem.parent.func;
+
+    const consoleUrl = getConsoleUrlFromEndpoint(clientConfig.endpoint);
+    // https://console.streamlux.com/console/functions/function/logs?id=60b1836a8e5d9&project=605ce39a30c01
+
+    const url = `${consoleUrl}/functions/function/logs?id=${func.$id}&project=${clientConfig.projectId}`;
+    openUrl(url);
+}
--- a/src/commands/functions/openFunctionSettingsInBrowser.ts
+++ b/src/commands/functions/openFunctionSettingsInBrowser.ts
@ -0,0 +1,15 @@
+import { clientConfig } from '../../client';
+import { ExecutionsTreeItem } from '../../tree/functions/executions/ExecutionsTreeItem';
+import { openUrl } from '../../utils/openUrl';
+import { getConsoleUrlFromEndpoint } from '../users/openUserInConsole';
+
+export async function openFunctionSettingsInBrowser(treeItem: ExecutionsTreeItem): Promise<void> {
+
+    const func = treeItem.parent.func;
+
+    const consoleUrl = getConsoleUrlFromEndpoint(clientConfig.endpoint);
+    // https://console.streamlux.com/console/functions/function/settings?id=60b1836a8e5d9&project=605ce39a30c01
+
+    const url = `${consoleUrl}/functions/function/settings?id=${func.$id}&project=${clientConfig.projectId}`;
+    openUrl(url);
+}
--- a/src/commands/functions/openFunctionTagsInBrowser.ts
+++ b/src/commands/functions/openFunctionTagsInBrowser.ts
@ -0,0 +1,13 @@
+import { clientConfig } from '../../client';
+import { ExecutionsTreeItem } from '../../tree/functions/executions/ExecutionsTreeItem';
+import { openUrl } from '../../utils/openUrl';
+import { getConsoleUrlFromEndpoint } from '../users/openUserInConsole';
+
+export async function openFunctionTagsInBrowser(treeItem: ExecutionsTreeItem): Promise<void> {
+    const func = treeItem.parent.func;
+
+    const consoleUrl = getConsoleUrlFromEndpoint(clientConfig.endpoint);
+    // https://console.streamlux.com/console/functions/function?id=60b1836a8e5d9&project=605ce39a30c01
+    const url = `${consoleUrl}/functions/function?id=${func.$id}&project=${clientConfig.projectId}`;
+    openUrl(url);
+}
--- a/src/commands/functions/viewExecutionErrors.ts
+++ b/src/commands/functions/viewExecutionErrors.ts
@ -0,0 +1,16 @@
+import { Execution } from '../../appwrite';
+import { ExecutionTreeItem } from "../../tree/functions/executions/ExecutionTreeItem";
+import { openReadOnlyContent } from "../../ui/openReadonlyContent";
+
+export async function viewExecutionErrors(executionItem: ExecutionTreeItem | Execution): Promise<void> {
+    if (executionItem === undefined) {
+        return;
+    }
+
+    let execution = executionItem as Execution;
+
+    if (executionItem instanceof ExecutionTreeItem) {
+        execution = executionItem.execution;
+    }
+    await openReadOnlyContent({ label: `Execution stderr`, fullId: `${execution.$id}-errors.txt` }, execution.stderr, '.txt');
+}
--- a/src/commands/functions/viewExecutionOutput.ts
+++ b/src/commands/functions/viewExecutionOutput.ts
@ -0,0 +1,19 @@
+import { Execution } from '../../appwrite';
+import { ExecutionTreeItem } from "../../tree/functions/executions/ExecutionTreeItem";
+import { openReadOnlyContent } from "../../ui/openReadonlyContent";
+
+export async function viewExecutionOutput(executionItem: ExecutionTreeItem | Execution): Promise<void> {
+    if (executionItem === undefined) {
+        return;
+    }
+
+
+    let execution = executionItem as Execution;
+
+    if (executionItem instanceof ExecutionTreeItem) {
+        execution = executionItem.execution;
+    }
+    console.log(execution.dateCreated);
+
+    await openReadOnlyContent({ label: `Execution stdout`, fullId: `${execution.$id}-output.txt` }, execution.stdout, '.txt');
+}
--- a/src/commands/openDocumentation.ts
+++ b/src/commands/openDocumentation.ts
@ -5,7 +5,8 @@ const documentationLinks = {
    users: 'https://appwrite.io/docs/server/users',
    database: 'https://appwrite.io/docs/client/database',
    health: 'https://appwrite.io/docs/server/health',
-    storage: 'https://appwrite.io/docs/client/storage'
+    storage: 'https://appwrite.io/docs/client/storage',
+    functions: 'https://appwrite.io/docs/server/functions'
 };

 type DocsPage = keyof typeof documentationLinks;
--- a/src/commands/registerCommands.ts
+++ b/src/commands/registerCommands.ts
@ -25,6 +25,24 @@ 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 { viewMore } from './common/viewMore';

 class CommandRegistrar {
    constructor(private readonly context: ExtensionContext) {}
@ -56,6 +74,10 @@ export function registerCommands(context: ExtensionContext): void {
        });
    };

+    /** Common **/
+    registerCommand("editValue", editValue);
+    registerCommand("viewMore", viewMore);
+
    /** General **/
    registerCommand("Connect", connectAppwrite, "all");

@ -98,4 +120,23 @@ export function registerCommands(context: ExtensionContext): void {
    registerCommand("setActiveProject", setActiveProject, "all");
    registerCommand("refreshProjects", undefined, "projects");
    registerCommand("removeProject", removeProject, "all");
+
+    /** Functions **/
+    registerCommand("refreshFunctions", undefined, "functions");
+    registerCommand("CreateExecution", createExecution, "functions");
+    registerCommand("CreateTag", createTag, "functions");
+    registerCommand("activateTag", activateTag, "functions");
+    registerCommand("deleteTag", deleteTag, "functions");
+    registerCommand("deleteFunction", deleteFunction, "functions");
+    registerCommand("openFunctionsDocumentation", () => openDocumentation("functions"));
+    registerCommand("createFunction", createFunction, "functions");
+    registerCommand("createFunctionVar", createFunctionVar, "functions");
+    registerCommand("deleteFunctionVar", deleteFunctionVar, "functions");
+    registerCommand("viewExecutionErrors", viewExecutionErrors);
+    registerCommand("viewExecutionOutput", viewExecutionOutput);
+    registerCommand("copyExecutionOutput", copyExecutionOutput);
+    registerCommand("copyExecutionErrors", copyExecutionErrors);
+    registerCommand("openExecutionsInBrowser", openExecutionsInBrowser);
+    registerCommand("openFunctionTagsInBrowser", openFunctionTagsInBrowser);
+    registerCommand("openFunctionSettingsInBrowser", openFunctionSettingsInBrowser);
 }
--- a/src/commands/users/createUser.ts
+++ b/src/commands/users/createUser.ts
@ -19,7 +19,7 @@ export async function createUser(): Promise<void> {
        password: true,
        prompt: "Enter user password",
        validateInput: (value) => {
-            if (value.length <= 6) {
+            if (value.length < 6) {
                return "Password must be at least 6 characters long.";
            }
            if (value.length > 32) {
--- a/src/commands/users/deleteUser.ts
+++ b/src/commands/users/deleteUser.ts
@ -20,7 +20,7 @@ export async function deleteUser(userTreeItem: UserTreeItem): Promise<void> {
    );

    if (shouldDeleteUser === DialogResponses.yes) {
-        await usersClient.delete(userId);
+            await usersClient.delete(userId);
        refreshTree("users");
    }
 }
--- a/src/commands/users/openUserInConsole.ts
+++ b/src/commands/users/openUserInConsole.ts
@ -3,7 +3,7 @@ import { commands, Uri } from "vscode";
 import { clientConfig } from "../../client";
 import { UserTreeItem } from "../../tree/users/UserTreeItem";

-function getConsoleUrlFromEndpoint(endpoint: string): string {
+export function getConsoleUrlFromEndpoint(endpoint: string): string {
    const url = new URL(endpoint);
    return `${url.origin}/console`;
 }
--- a/src/constants.ts
+++ b/src/constants.ts
@ -1,4 +1,197 @@
-import type { SDK } from './appwrite';
+import type { SDK } from "./appwrite";

 // eslint-disable-next-line @typescript-eslint/no-var-requires
-export const AppwriteSDK: SDK = require('node-appwrite') as SDK;
+export const AppwriteSDK: SDK = require("node-appwrite") as SDK;
+
+export const appwriteSystemEvents = [
+    {
+        name: "account.create",
+        description: "This event triggers when the account is created.",
+    },
+    {
+        name: "account.update.email",
+        description: "This event triggers when the account email address is updated.",
+    },
+    {
+        name: "account.update.name",
+        description: "This event triggers when the account name is updated.",
+    },
+    {
+        name: "account.update.password",
+        description: "This event triggers when the account password is updated.",
+    },
+    {
+        name: "account.update.prefs",
+        description: "This event triggers when the account preferences are updated.",
+    },
+    {
+        name: "account.recovery.create",
+        description: "This event triggers when the account recovery token is created.",
+    },
+    {
+        name: "account.recovery.update",
+        description: "This event triggers when the account recovery token is validated.",
+    },
+    {
+        name: "account.verification.create",
+        description: "This event triggers when the account verification token is created.",
+    },
+    {
+        name: "account.verification.update",
+        description: "This event triggers when the account verification token is validated.",
+    },
+    {
+        name: "account.delete",
+        description: "This event triggers when the account is deleted.",
+    },
+    {
+        name: "account.sessions.create",
+        description: "This event triggers when the account session is created.",
+    },
+    {
+        name: "account.delete",
+        description: "This event triggers when the account is deleted.",
+    },
+    {
+        name: "account.sessions.create",
+        description: "This event triggers when the account session is created.",
+    },
+    {
+        name: "account.sessions.delete",
+        description: "This event triggers when the account session is deleted.",
+    },
+    {
+        name: "database.collections.create",
+        description: "This event triggers when a database collection is created.",
+    },
+    {
+        name: "database.collections.update",
+        description: "This event triggers when a database collection is updated.",
+    },
+    {
+        name: "database.collections.delete",
+        description: "This event triggers when a database collection is deleted.",
+    },
+    {
+        name: "database.documents.create",
+        description: "This event triggers when a database document is created.",
+    },
+    {
+        name: "database.documents.update",
+        description: "This event triggers when a database document is updated.",
+    },
+    {
+        name: "database.documents.delete",
+        description: "This event triggers when a database document is deleted.",
+    },
+    {
+        name: "functions.create",
+        description: "This event triggers when a function is created.",
+    },
+    {
+        name: "functions.update",
+        description: "This event triggers when a function is updated.",
+    },
+    {
+        name: "functions.delete",
+        description: "This event triggers when a function is deleted.",
+    },
+    {
+        name: "functions.tags.create",
+        description: "This event triggers when a function tag is created.",
+    },
+    {
+        name: "functions.tags.update",
+        description: "This event triggers when a function tag is updated.",
+    },
+    {
+        name: "functions.tags.delete",
+        description: "This event triggers when a function tag is deleted.",
+    },
+    {
+        name: "functions.executions.create",
+        description: "This event triggers when a function execution is created.",
+    },
+    {
+        name: "functions.executions.update",
+        description: "This event triggers when a function execution is updated.",
+    },
+    {
+        name: "storage.files.create",
+        description: "This event triggers when a storage file is created.",
+    },
+    {
+        name: "storage.files.update",
+        description: "This event triggers when a storage file is updated.",
+    },
+    {
+        name: "storage.files.delete",
+        description: "This event triggers when a storage file is deleted.",
+    },
+    {
+        name: "users.create",
+        description: "This event triggers when a user is created from the users API.",
+    },
+    {
+        name: "users.update.prefs",
+        description: "This event triggers when a user preference is updated from the users API.",
+    },
+    {
+        name: "users.update.status",
+        description: "This event triggers when a user status is updated from the users API.",
+    },
+    {
+        name: "users.delete",
+        description: "This event triggers when a user is deleted from users API.",
+    },
+    {
+        name: "users.sessions.delete",
+        description: "This event triggers when a user session is deleted from users API.",
+    },
+    {
+        name: "teams.create",
+        description: "This event triggers when a team is created.",
+    },
+    {
+        name: "teams.update",
+        description: "This event triggers when a team is updated.",
+    },
+    {
+        name: "teams.delete",
+        description: "This event triggers when a team is deleted.",
+    },
+    {
+        name: "teams.memberships.create",
+        description: "This event triggers when a team memberships is created.",
+    },
+    {
+        name: "teams.memberships.update",
+        description: "This event triggers when a team membership is updated.",
+    },
+    {
+        name: "teams.memberships.update.status",
+        description: "This event triggers when a team memberships status is updated.",
+    },
+    {
+        name: "teams.memberships.delete",
+        description: "This event triggers when a team memberships is deleted.",
+    },
+];
+
+export const appwriteFunctionRuntimes = [
+    "dotnet-3.1",
+    "dotnet-5.0",
+    "dart-2.10",
+    "dart-2.12",
+    "deno-1.5",
+    "deno-1.6",
+    "deno-1.8",
+    "python-3.8",
+    "python-3.9",
+    "ruby-2.7",
+    "ruby-3.0",
+    "php-7.4",
+    "php-8.0",
+    "node-14.5",
+    "node-15.5",
+];
--- a/src/extension.ts
+++ b/src/extension.ts
@ -4,6 +4,7 @@ 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";
@ -16,12 +17,14 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
    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);
@ -35,6 +38,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
        database: databaseTreeItemProvider,
        storage: storageTreeItemProvider,
        projects: projectsTreeItemProvider,
+        functions: functionsTreeItemProvider
    };

    registerCommands(context);
--- a/src/extensionVariables.ts
+++ b/src/extensionVariables.ts
@ -1,5 +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';
@ -12,12 +13,13 @@ export type AppwriteTree = {
    database?: DatabaseTreeItemProvider;
    storage?: StorageTreeItemProvider;
    projects?: ProjectsTreeItemProvider;
+    functions?: FunctionsTreeItemProvider;
 };

 export type Ext = {
-    context?: ExtensionContext;
-    outputChannel?: AppwriteOutputChannel;
+    context: ExtensionContext;
+    outputChannel: AppwriteOutputChannel;
    tree?: AppwriteTree;
 };

-export const ext: Ext = {};
+export const ext: Ext = {} as Ext;
--- a/src/settings.ts
+++ b/src/settings.ts
@ -6,6 +6,7 @@ export type AppwriteProjectConfiguration = {
    endpoint: string;
    console?: string;
    projectId: string;
+    selfSigned: boolean;
    secret: string;
 };

--- a/src/tree/common/EditableTreeItemBase.ts
+++ b/src/tree/common/EditableTreeItemBase.ts
@ -0,0 +1,13 @@
+import { TreeItem } from "vscode";
+
+export abstract class EditableTreeItemBase<T> extends TreeItem {
+    public abstract setValue(value: T): Promise<void>;
+
+    constructor(contextValuePrefix: string, public readonly value: T, description?: string) {
+        super(typeof value === "string" ? value : "No label");
+        this.contextValue = `editable_${contextValuePrefix}`;
+        this.description = description ?? contextValuePrefix;
+    }
+
+    public abstract prompt(): Promise<void>;
+}
--- a/src/tree/common/EnumEditableTreeItem.ts
+++ b/src/tree/common/EnumEditableTreeItem.ts
@ -0,0 +1,38 @@
+import { QuickPickItem, QuickPickOptions, window } from "vscode";
+import { EditableTreeItemBase } from "./EditableTreeItemBase";
+
+export abstract class EnumEditableTreeItemBase extends EditableTreeItemBase<string[]> {
+    public abstract options: string[] | QuickPickItem[];
+
+    public quickPickOptions: QuickPickOptions;
+
+    constructor(contextValuePrefix: string, public readonly value: string[], description?: string) {
+        super(contextValuePrefix, value, description);
+        this.quickPickOptions = {};
+    }
+
+    public async prompt(): Promise<void> {
+
+        const value = await window.showQuickPick(
+            this.options.map<QuickPickItem>((option: QuickPickItem | string): QuickPickItem => {
+                if (typeof option === "string") {
+                    return { label: option, picked: this.value.includes(option) };
+                }
+                const picked = this.value.includes(option.label);
+                return { ...option, picked, alwaysShow: picked };
+            }).sort((a, b) => {
+                if (a.picked) {
+                    return -1;
+                }
+                if (b.picked) {
+                    return 1;
+                }
+                return 0;
+            }),
+            { ...this.quickPickOptions, canPickMany: true }
+        );
+        if (value !== undefined) {
+            this.setValue(value.map((item) => item.label));
+        }
+    }
+}
--- a/src/tree/common/SimpleEditableTreeItem.ts
+++ b/src/tree/common/SimpleEditableTreeItem.ts
@ -0,0 +1,18 @@
+import { TreeItem, window } from "vscode";
+
+export class EditableTreeItem extends TreeItem {
+    public readonly setValue: (value: string) => Promise<void>;
+
+    constructor(label: string, contextValuePrefix: string, public readonly value: string, setValue: (value: string) => Promise<void>) {
+        super(label);
+        this.setValue = setValue;
+        this.contextValue = `editable_${contextValuePrefix}`;
+    }
+
+    public async prompt(): Promise<void> {
+        const value = await window.showInputBox({ value: this.value });
+        if (value !== undefined) {
+            this.setValue(value);
+        }
+    }
+}
--- a/src/tree/common/StringEditableTreeItem.ts
+++ b/src/tree/common/StringEditableTreeItem.ts
@ -0,0 +1,22 @@
+import { InputBoxOptions, window } from "vscode";
+import { EditableTreeItemBase } from "./EditableTreeItemBase";
+
+export abstract class StringEditableTreeItemBase extends EditableTreeItemBase<string> {
+    public abstract setValue(value: string): Promise<void>;
+    public inputBoxOptions: InputBoxOptions;
+
+    constructor(contextValuePrefix: string, public readonly value: string, description?: string) {
+        super(contextValuePrefix, value, description);
+
+        this.inputBoxOptions = {
+            prompt: description,
+        };
+    }
+
+    public async prompt(): Promise<void> {
+        const value = await window.showInputBox({ value: this.value, ...this.inputBoxOptions });
+        if (value !== undefined) {
+            this.setValue(value);
+        }
+    }
+}
--- a/src/tree/common/editable/EditableTreeItemBase.ts
+++ b/src/tree/common/editable/EditableTreeItemBase.ts
@ -0,0 +1,13 @@
+import { TreeItem } from "vscode";
+
+export abstract class EditableTreeItemBase<T> extends TreeItem {
+    public abstract setValue(value: T): Promise<void>;
+
+    constructor(contextValuePrefix: string, public readonly value: T, description?: string) {
+        super(typeof value === "string" ? value : "No label");
+        this.contextValue = `editable_${contextValuePrefix}`;
+        this.description = description ?? contextValuePrefix;
+    }
+
+    public abstract prompt(): Promise<void>;
+}
--- a/src/tree/common/editable/EnumEditableTreeItem.ts
+++ b/src/tree/common/editable/EnumEditableTreeItem.ts
@ -0,0 +1,38 @@
+import { QuickPickItem, QuickPickOptions, window } from "vscode";
+import { EditableTreeItemBase } from "./EditableTreeItemBase";
+
+export abstract class EnumEditableTreeItemBase extends EditableTreeItemBase<string[]> {
+    public abstract options: string[] | QuickPickItem[];
+
+    public quickPickOptions: QuickPickOptions;
+
+    constructor(contextValuePrefix: string, public readonly value: string[], description?: string) {
+        super(contextValuePrefix, value, description);
+        this.quickPickOptions = {};
+    }
+
+    public async prompt(): Promise<void> {
+
+        const value = await window.showQuickPick(
+            this.options.map<QuickPickItem>((option: QuickPickItem | string): QuickPickItem => {
+                if (typeof option === "string") {
+                    return { label: option, picked: this.value.includes(option) };
+                }
+                const picked = this.value.includes(option.label);
+                return { ...option, picked, alwaysShow: picked };
+            }).sort((a, b) => {
+                if (a.picked) {
+                    return -1;
+                }
+                if (b.picked) {
+                    return 1;
+                }
+                return 0;
+            }),
+            { ...this.quickPickOptions, canPickMany: true }
+        );
+        if (value !== undefined) {
+            this.setValue(value.map((item) => item.label));
+        }
+    }
+}
--- a/src/tree/common/editable/SimpleEditableTreeItem.ts
+++ b/src/tree/common/editable/SimpleEditableTreeItem.ts
@ -0,0 +1,18 @@
+import { TreeItem, window } from "vscode";
+
+export class EditableTreeItem extends TreeItem {
+    public readonly setValue: (value: string) => Promise<void>;
+
+    constructor(label: string, contextValuePrefix: string, public readonly value: string, setValue: (value: string) => Promise<void>) {
+        super(label);
+        this.setValue = setValue;
+        this.contextValue = `editable_${contextValuePrefix}`;
+    }
+
+    public async prompt(): Promise<void> {
+        const value = await window.showInputBox({ value: this.value });
+        if (value !== undefined) {
+            this.setValue(value);
+        }
+    }
+}
--- a/src/tree/common/editable/StringEditableTreeItem.ts
+++ b/src/tree/common/editable/StringEditableTreeItem.ts
@ -0,0 +1,22 @@
+import { InputBoxOptions, window } from "vscode";
+import { EditableTreeItemBase } from "./EditableTreeItemBase";
+
+export abstract class StringEditableTreeItemBase extends EditableTreeItemBase<string> {
+    public abstract setValue(value: string): Promise<void>;
+    public inputBoxOptions: InputBoxOptions;
+
+    constructor(contextValuePrefix: string, public readonly value: string, description?: string) {
+        super(contextValuePrefix, value, description);
+
+        this.inputBoxOptions = {
+            prompt: description,
+        };
+    }
+
+    public async prompt(): Promise<void> {
+        const value = await window.showInputBox({ value: this.value, ...this.inputBoxOptions });
+        if (value !== undefined) {
+            this.setValue(value);
+        }
+    }
+}
--- a/src/tree/database/DatabaseTreeItemProvider.ts
+++ b/src/tree/database/DatabaseTreeItemProvider.ts
@ -4,8 +4,8 @@ import AppwriteCall from "../../utils/AppwriteCall";
 import { Collection, CollectionsList } from "../../appwrite";
 import { CollectionTreeItem } from "./CollectionTreeItem";
 import { AppwriteSDK } from "../../constants";
-import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
 import { ext } from '../../extensionVariables';
+import { AppwriteTreeItemBase } from '../../ui/AppwriteTreeItemBase';

 export class DatabaseTreeItemProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
    private _onDidChangeTreeData: vscode.EventEmitter<vscode.TreeItem | undefined | void> = new vscode.EventEmitter<
@ -34,18 +34,18 @@ export class DatabaseTreeItemProvider implements vscode.TreeDataProvider<vscode.
        }

        if (parent instanceof AppwriteTreeItemBase) {
-            return parent.getChildren?.() ?? [];
+            return await parent.getChildren?.() ?? [];
        }

        const databaseSdk = new AppwriteSDK.Database(client);

        const collectionsList = await AppwriteCall<CollectionsList, CollectionsList>(databaseSdk.listCollections());
        if (collectionsList) {
-            const userTreeItems = collectionsList.collections.map((collection: Collection) => new CollectionTreeItem(collection, this)) ?? [];
+            const collectionTreeItems = collectionsList.collections.map((collection: Collection) => new CollectionTreeItem(collection, this)) ?? [];
            const headerItem: vscode.TreeItem = {
                label: `Total collections: ${collectionsList.sum}`,
            };
-            return [headerItem, ...userTreeItems];
+            return [headerItem, ...collectionTreeItems];
        }

        return [{ label: "No collections found" }];
--- a/src/tree/functions/FunctionTreeItem.ts
+++ b/src/tree/functions/FunctionTreeItem.ts
@ -0,0 +1,30 @@
+import { MarkdownString, ThemeIcon, TreeItem, TreeItemCollapsibleState } from "vscode";
+import { Function } from "../../appwrite";
+import { AppwriteTreeItemBase } from "../../ui/AppwriteTreeItemBase";
+import { msToDate } from '../../utils/date';
+import { ExecutionsTreeItem } from './executions/ExecutionsTreeItem';
+import { FunctionsTreeItemProvider } from './FunctionsTreeItemProvider';
+import { FunctionSettingsTreeItem } from './settings/FunctionSettingsTreeItem';
+import { TagsTreeItem } from './tags/TagsTreeItem';
+
+export class FunctionTreeItem extends AppwriteTreeItemBase {
+    constructor(public func: Function, public readonly provider: FunctionsTreeItemProvider) {
+        super(undefined, func.name);
+        this.tooltip = new MarkdownString(`ID: ${func.$id}  \nLast updated: ${msToDate(func.dateUpdated)}  \nCreated: ${msToDate(func.dateCreated)}`);
+        this.description = func.env;
+    }
+
+    public async getChildren(): Promise<TreeItem[]> {
+        return [new FunctionSettingsTreeItem(this), new TagsTreeItem(this), new ExecutionsTreeItem(this)];
+    }
+
+    public async refresh(): Promise<void> {
+        this.provider.refreshChild(this);
+    }
+
+    collapsibleState = TreeItemCollapsibleState.Collapsed;
+
+    contextValue = "function";
+
+    iconPath = new ThemeIcon("symbol-event");
+}
--- a/src/tree/functions/FunctionsTreeItemProvider.ts
+++ b/src/tree/functions/FunctionsTreeItemProvider.ts
@ -0,0 +1,52 @@
+import * as vscode from "vscode";
+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";
+
+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;
+
+    refresh(): void {
+        ext.outputChannel?.appendLine("Refreshing functions tree provider...");
+        this._onDidChangeTreeData.fire();
+    }
+
+    refreshChild(child: vscode.TreeItem): void {
+        this._onDidChangeTreeData.fire(child);
+    }
+
+    getTreeItem(element: vscode.TreeItem): vscode.TreeItem {
+        return element;
+    }
+
+    async getChildren(parent?: AppwriteTreeItemBase | TreeItem): Promise<vscode.TreeItem[]> {
+        if (client === undefined) {
+            return Promise.resolve([]);
+        }
+
+        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 [];
+    }
+}
--- a/src/tree/functions/executions/ExecutionTreeItem.ts
+++ b/src/tree/functions/executions/ExecutionTreeItem.ts
@ -0,0 +1,83 @@
+import { MarkdownString, ThemeColor, ThemeIcon, TreeItem } from "vscode";
+import { Execution, ExecutionStatus } from "../../../appwrite";
+import { msToDate } from "../../../utils/date";
+import { ExecutionsTreeItem } from "./ExecutionsTreeItem";
+
+const executionStatusIcons: Record<ExecutionStatus, ThemeIcon> = {
+    processing: new ThemeIcon("loading"),
+    waiting: new ThemeIcon("circle-outline"),
+    completed: new ThemeIcon("circle-filled", new ThemeColor("testing.iconPassed")),
+    failed: new ThemeIcon("circle-filled", new ThemeColor("testing.iconFailed")),
+};
+
+export class ExecutionTreeItem extends TreeItem {
+    public isAutoRefreshing: boolean = false;
+    private refreshCount: number = 0;
+
+    constructor(public readonly parent: ExecutionsTreeItem, public execution: Execution) {
+        super(execution.$id);
+        this.label = this.getLabel(execution);
+        this.iconPath = executionStatusIcons[execution.status];
+        const md = `Id: ${execution.$id}  \nCreated: ${this.getCreated(execution)}  \nTrigger: ${execution.trigger}`;
+        this.tooltip = new MarkdownString(md);
+        this.description = execution.trigger;
+        this.contextValue = this.getContextValue(execution);
+        this.isAutoRefreshing = execution.status === "processing" || execution.status === "waiting";
+        // if (this.isAutoRefreshing) {
+        //     this.autoRefresh();
+        // }
+    }
+
+    // async autoRefresh(): Promise<void> {
+    //     if (!this.isAutoRefreshing && this.refreshCount < 5) {
+    //         return;
+    //     }
+    //     this.refreshCount++;
+    //     ext.outputChannel.appendLog("Refreshing execution.");
+    //     const execution = await functionsClient?.getExecution(this.parent.parent.func.$id, this.execution.$id);
+
+    //     if (!execution) {
+    //         ext.outputChannel.appendLog("Execution is undefined");
+    //         this.isAutoRefreshing = false;
+    //         return;
+    //     }
+    //     this.execution = execution;
+    //     this.contextValue = this.getContextValue(execution);
+    //     this.iconPath = executionStatusIcons[execution.status];
+    //     this.label = this.getLabel(execution);
+    //     this.isAutoRefreshing = execution.status === "processing" || execution.status === "waiting";
+    //     ext.tree?.functions?.refreshChild(this);
+    //     await sleep(1000);
+    //     this.autoRefresh();
+    // }
+
+    getLabel(execution: Execution): string {
+        if (execution.status === "completed" || execution.status === "failed") {
+            return `${this.getCreated(execution)} (${this.getExecutionTime(execution)}s)`;
+        }
+        return `${this.getCreated(execution)} (${execution.status})`;
+    }
+
+    getExecutionTime(execution: Execution): string {
+        return execution.time.toPrecision(2);
+    }
+
+    getContextValue(execution: Execution): string {
+        if (execution.status === "completed" || execution.status === "failed") {
+            if (execution.stderr === "" && execution.stdout === "") {
+                return "execution_noErrorOrOutput";
+            }
+            if (execution.stderr === "") {
+                return "execution_outputOnly";
+            }
+            if (execution.stdout === "") {
+                return "execution_errorOnly";
+            }
+        }
+        return "execution";
+    }
+
+    getCreated(execution: Execution): string {
+        return msToDate(execution.dateCreated);
+    }
+}
--- a/src/tree/functions/executions/ExecutionsTreeItem.ts
+++ b/src/tree/functions/executions/ExecutionsTreeItem.ts
@ -0,0 +1,61 @@
+import { ThemeIcon, TreeItem, TreeItemCollapsibleState } from "vscode";
+import { Execution, ExecutionList } from "../../../appwrite";
+import { functionsClient } from "../../../client";
+import { ExecutionTreeItem } from "./ExecutionTreeItem";
+import { FunctionTreeItem } from "../FunctionTreeItem";
+import { ext } from "../../../extensionVariables";
+import { AppwriteTreeItemBase } from "../../../ui/AppwriteTreeItemBase";
+
+export class ExecutionsTreeItem extends AppwriteTreeItemBase<FunctionTreeItem> {
+    constructor(public readonly parent: FunctionTreeItem) {
+        super(parent, "Executions");
+    }
+
+    private executionsToShow = 10;
+
+    public async getChildren(): Promise<TreeItem[]> {
+        if (!functionsClient) {
+            return [];
+        }
+        const executions: ExecutionList | undefined = await functionsClient.listExecutions(
+            this.parent.func.$id,
+            undefined,
+            this.executionsToShow,
+            undefined,
+            "DESC"
+        );
+        const children = executions?.executions.map((execution: Execution) => new ExecutionTreeItem(this, execution)) ?? [
+            new TreeItem("No executions."),
+        ];
+        if (children.length === 0) {
+            children.push(new TreeItem("No executions."));
+        }
+        ext.outputChannel.appendLog(`Found ${executions?.sum} executions`);
+        if (executions?.sum ?? (0 > this.executionsToShow && this.executionsToShow !== 100)) {
+            const viewMoreItem: TreeItem = {
+                command: {
+                    command: "vscode-appwrite.viewMore",
+                    arguments: [this],
+                    title: "View more",
+                },
+                label: "View more...",
+            };
+            children.push(viewMoreItem);
+        }
+        return children;
+    }
+
+    collapsibleState = TreeItemCollapsibleState.Collapsed;
+
+    contextValue = "executions";
+
+    iconPath = new ThemeIcon("history");
+
+    async viewMore(): Promise<void> {
+        this.executionsToShow += 10;
+        if (this.executionsToShow > 100) {
+            this.executionsToShow = 100;
+        }
+        ext.tree?.functions?.refreshChild(this);
+    }
+}
--- a/src/tree/functions/settings/EventsTreeItem.ts
+++ b/src/tree/functions/settings/EventsTreeItem.ts
@ -0,0 +1,31 @@
+import { QuickPickItem, QuickPickOptions } from "vscode";
+import { Function } from "../../../appwrite";
+import { functionsClient } from "../../../client";
+import { appwriteSystemEvents } from "../../../constants";
+import { ext } from "../../../extensionVariables";
+import { EnumEditableTreeItemBase } from "../../common/editable/EnumEditableTreeItem";
+import { FunctionSettingsTreeItem } from "./FunctionSettingsTreeItem";
+
+export class EventsTreeItem extends EnumEditableTreeItemBase {
+    public quickPickOptions: QuickPickOptions = {
+        placeHolder: "Select which system events should trigger this function.",
+        matchOnDescription: true
+    };
+    public options: string[] | QuickPickItem[] = appwriteSystemEvents.map((event) => ({
+        label: event.name,
+        description: event.description.replace("This event t", "T")
+    }));
+
+    public readonly func: Function;
+
+    constructor(public readonly parent: FunctionSettingsTreeItem) {
+        super("System events", parent.func.events);
+        this.func = parent.func;
+        this.label = parent.func.events.length === 0 ? 'None' : `${parent.func.events.length} active`;
+    }
+
+    public async setValue(value: string[]): Promise<void> {
+        await functionsClient?.update(this.func.$id, this.func.name, [], this.func.vars, value, this.func.schedule, this.func.timeout);
+        ext.tree?.functions?.refresh();
+    }
+}
--- a/src/tree/functions/settings/FunctionSettingsTreeItem.ts
+++ b/src/tree/functions/settings/FunctionSettingsTreeItem.ts
@ -0,0 +1,45 @@
+import { ThemeIcon, TreeItem, TreeItemCollapsibleState } from "vscode";
+import { Function } from "../../../appwrite";
+import { functionsClient } from "../../../client";
+import { AppwriteTreeItemBase } from '../../../ui/AppwriteTreeItemBase';
+import { ChildTreeItem } from "../../ChildTreeItem";
+import { FunctionTreeItem } from "../FunctionTreeItem";
+import { EventsTreeItem } from "./EventsTreeItem";
+import { NameTreeItem } from "./NameTreeItem";
+import { ScheduleTreeItem } from "./ScheduleTreeItem";
+import { TimeoutTreeItem } from "./TimeoutTreeItem";
+import { VarsTreeItem } from "./VarsTreeItem";
+
+export class FunctionSettingsTreeItem extends AppwriteTreeItemBase<FunctionTreeItem> {
+    public readonly func: Function;
+
+    constructor(public readonly parent: FunctionTreeItem) {
+        super(parent, "Settings");
+        this.func = parent.func;
+    }
+
+    public async getChildren(): Promise<TreeItem[]> {
+        if (!functionsClient) {
+            return [];
+        }
+
+        const children = [
+            new NameTreeItem(this),
+            new ScheduleTreeItem(this),
+            new TimeoutTreeItem(this.func),
+            new EventsTreeItem(this),
+            new VarsTreeItem(this),
+        ];
+        return children;
+    }
+
+    labelItem(label: string, value: string): TreeItem {
+        return new ChildTreeItem(this, { label: value === "" ? "None" : value, description: label });
+    }
+
+    collapsibleState = TreeItemCollapsibleState.Collapsed;
+
+    contextValue = "functionSettings";
+
+    iconPath = new ThemeIcon("settings");
+}
--- a/src/tree/functions/settings/NameTreeItem.ts
+++ b/src/tree/functions/settings/NameTreeItem.ts
@ -0,0 +1,43 @@
+import { InputBoxOptions, MarkdownString } from "vscode";
+import { Function } from "../../../appwrite";
+import { functionsClient } from "../../../client";
+import { ext } from "../../../extensionVariables";
+import { StringEditableTreeItemBase } from '../../common/editable/StringEditableTreeItem';
+import { FunctionSettingsTreeItem } from "./FunctionSettingsTreeItem";
+
+const tooltip = "Function name";
+const description = "Function name. Max length: 128 chars.";
+const tooLongInvalid = "Value exceeds maximum length of 128 characters.";
+
+export function validateFunctionName(value: string): string | undefined {
+    if (value.length > 128) {
+        return tooLongInvalid;
+    }
+}
+
+export class NameTreeItem extends StringEditableTreeItemBase {
+    public readonly func: Function;
+
+    inputBoxOptions: InputBoxOptions = {
+        validateInput: (value) => {
+            if (value.length > 128) {
+                return tooLongInvalid;
+            }
+        },
+        prompt: description,
+    };
+
+    public async setValue(value: string): Promise<void> {
+        if (value.length === 0) {
+            return;
+        }
+        await functionsClient?.update(this.func.$id, value, [], this.func.vars, this.func.events, this.func.schedule, this.func.timeout);
+        ext.tree?.functions?.refresh();
+    }
+
+    constructor(private readonly parent: FunctionSettingsTreeItem) {
+        super("Name", parent.func.name);
+        this.func = parent.func;
+        this.tooltip = new MarkdownString(tooltip);
+    }
+}
--- a/src/tree/functions/settings/ScheduleTreeItem.ts
+++ b/src/tree/functions/settings/ScheduleTreeItem.ts
@ -0,0 +1,44 @@
+import { InputBoxOptions, MarkdownString } from "vscode";
+import { Function } from "../../../appwrite";
+import { functionsClient } from "../../../client";
+import { ext } from "../../../extensionVariables";
+import cron from "cron-validate";
+import { FunctionSettingsTreeItem } from "./FunctionSettingsTreeItem";
+import cronstrue from "cronstrue";
+import { StringEditableTreeItemBase } from '../../common/editable/StringEditableTreeItem';
+
+export class ScheduleTreeItem extends StringEditableTreeItemBase {
+    private readonly func: Function;
+
+    inputBoxOptions: InputBoxOptions = {
+        validateInput: (value) => {
+            if (value === "") {
+                return;
+            }
+            const cronResult = cron(value);
+            if (!cronResult.isValid()) {
+                return cronResult.getError().join(", ");
+            }
+        },
+        value: this.value === "" ? "0 0 * * *" : this.value,
+        prompt: "Function execution schedule in CRON format. Leave blank for no schedule. https://crontab.guru/examples.html",
+    };
+
+    public async setValue(value: string): Promise<void> {
+        await functionsClient?.update(this.func.$id, this.func.name, [], this.func.vars, this.func.events, value === "" ? undefined : value, this.func.timeout);
+        ext.tree?.functions?.refresh();
+    }
+
+    constructor(private readonly parent: FunctionSettingsTreeItem) {
+        super("Schedule", parent.func.schedule);
+        this.func = parent.func;
+        this.tooltip = new MarkdownString(`Function execution schedule in CRON format`);
+        this.label = `${this.value}`;
+        const cronResult = cron(parent.func.schedule);
+        if (cronResult.isValid()) {
+            this.label = cronstrue.toString(this.value, { verbose: true });
+        } else {
+            this.label = this.value === "" ? "None" : "Invalid CRON";
+        }
+    }
+}
--- a/src/tree/functions/settings/TimeoutTreeItem.ts
+++ b/src/tree/functions/settings/TimeoutTreeItem.ts
@ -0,0 +1,48 @@
+import { InputBoxOptions, MarkdownString } from "vscode";
+import { Function } from "../../../appwrite";
+import { functionsClient } from "../../../client";
+import { ext } from "../../../extensionVariables";
+import { StringEditableTreeItemBase } from "../../common/editable/StringEditableTreeItem";
+
+function isNumeric(str: string) {
+    console.log("here");
+    return !isNaN(+str);
+}
+
+export class TimeoutTreeItem extends StringEditableTreeItemBase {
+    inputBoxOptions: InputBoxOptions = {
+        validateInput: (value) => {
+            if (!isNumeric(value)) {
+                return "Input must be an integer.";
+            }
+
+            if (+value > 900) {
+                return "Value exceeds the maximum of 900 seconds (15 minutes)";
+            }
+
+            if (+value < 0) {
+                return "Value cannot be negative";
+            }
+        },
+        prompt: "Function maximum execution time in seconds. Maximum of 900 seconds (15 minutes).",
+    };
+
+    public async setValue(value: string): Promise<void> {
+        await functionsClient?.update(
+            this.func.$id,
+            this.func.name,
+            [],
+            this.func.vars,
+            this.func.events,
+            this.func.schedule,
+            parseInt(value)
+        );
+        ext.tree?.functions?.refresh();
+    }
+
+    constructor(private readonly func: Function) {
+        super("Timeout", func.timeout.toString());
+        this.tooltip = new MarkdownString(`Function maximum execution time in seconds.`);
+        this.label = `${this.value}s`;
+    }
+}
--- a/src/tree/functions/settings/VarTreeItem.ts
+++ b/src/tree/functions/settings/VarTreeItem.ts
@ -0,0 +1,64 @@
+import { InputBoxOptions, MarkdownString, window } from "vscode";
+import { Function } from "../../../appwrite";
+import { functionsClient } from "../../../client";
+import { ext } from "../../../extensionVariables";
+import { StringEditableTreeItemBase } from "../../common/editable/StringEditableTreeItem";
+import { VarsTreeItem } from "./VarsTreeItem";
+
+const tooltip = "Environment var";
+const description = "Function name. Max length: 128 chars.";
+const tooLongInvalid = "Value exceeds maximum length of 128 characters.";
+
+export async function keyValuePrompt(keyInit?: string, valueInit?: string): Promise<{ key: string; value: string } | undefined> {
+    const key = await window.showInputBox({ value: keyInit, prompt: "Environment variable name" });
+    if (key === undefined) {
+        return;
+    }
+    const value = await window.showInputBox({ value: valueInit, prompt: "Environment variable value" });
+    if (value === undefined) {
+        return;
+    }
+    return { key, value };
+}
+
+export class VarTreeItem extends StringEditableTreeItemBase {
+    public readonly func: Function;
+
+    inputBoxOptions: InputBoxOptions = {
+        validateInput: (value) => {
+            if (value.length > 128) {
+                return tooLongInvalid;
+            }
+        },
+        prompt: description,
+    };
+
+    public async setValue(value: string, key?: string): Promise<void> {
+        if (value.length === 0) {
+            return;
+        }
+        const newVars = { ...this.func.vars };
+        newVars[this.key] = value;
+        if (key) {
+            delete newVars[this.key];
+            newVars[key] = value;
+        }
+        await functionsClient?.update(this.func.$id, this.func.name, [], newVars, this.func.events, this.func.schedule, this.func.timeout);
+        ext.tree?.functions?.refresh();
+    }
+
+    constructor(public readonly parent: VarsTreeItem, public readonly key: string, value: string) {
+        super("var", value);
+        this.func = parent.parent.func;
+        this.tooltip = new MarkdownString(tooltip);
+        this.label = `${key}=${value}`;
+        this.description = undefined;
+    }
+
+    public async prompt(): Promise<void> {
+        const keyval = await keyValuePrompt(this.key, this.value);
+        if (keyval) {
+            this.setValue(keyval.value, keyval.key);
+        }
+    }
+}
--- a/src/tree/functions/settings/VarsTreeItem.ts
+++ b/src/tree/functions/settings/VarsTreeItem.ts
@ -0,0 +1,21 @@
+import { TreeItem, TreeItemCollapsibleState } from "vscode";
+import { Vars } from "../../../appwrite";
+import { AppwriteTreeItemBase } from '../../../ui/AppwriteTreeItemBase';
+import { FunctionSettingsTreeItem } from "./FunctionSettingsTreeItem";
+import { VarTreeItem } from "./VarTreeItem";
+
+export class VarsTreeItem extends AppwriteTreeItemBase<FunctionSettingsTreeItem> {
+    public readonly vars: Vars;
+
+    constructor(parent: FunctionSettingsTreeItem) {
+        super(parent, "Environment variables");
+        this.vars = parent.func.vars;
+        this.description = undefined;
+    }
+
+    public async getChildren(): Promise<TreeItem[]> {
+        return Object.keys(this.vars).map((key) => new VarTreeItem(this, key, this.vars[key]));
+    }
+    contextValue = "vars";
+    collapsibleState = TreeItemCollapsibleState.Collapsed;
+}
--- a/src/tree/functions/tags/TagTreeItem.ts
+++ b/src/tree/functions/tags/TagTreeItem.ts
@ -0,0 +1,17 @@
+import { MarkdownString, ThemeIcon, TreeItem } from "vscode";
+import { Tag } from '../../../appwrite';
+import { msToDate } from '../../../utils/date';
+import { TagsTreeItem } from './TagsTreeItem';
+
+export class TagTreeItem extends TreeItem {
+    constructor(public readonly parent: TagsTreeItem, public readonly tag: Tag) {
+        super(tag.$id);
+        const func = parent.parent.func;
+        const active = func.tag === tag.$id;
+        this.label = `${msToDate(tag.dateCreated)}${active ? ' (Active)' : ''}`;
+        this.description = tag.$id;
+        this.iconPath = new ThemeIcon(active ? 'circle-large-filled' : 'circle-large-outline');
+        this.contextValue = `tag${active ? '_active' : ''}`;
+        this.tooltip = new MarkdownString(`ID: ${tag.$id}  \nCreated: ${msToDate(tag.dateCreated)}  \nCommand: ${tag.command}  \nSize: ${tag.size}B`);
+    }
+}
--- a/src/tree/functions/tags/TagsTreeItem.ts
+++ b/src/tree/functions/tags/TagsTreeItem.ts
@ -0,0 +1,40 @@
+import { ThemeIcon, TreeItem, TreeItemCollapsibleState } from "vscode";
+import { functionsClient } from "../../../client";
+import { AppwriteTreeItemBase } from '../../../ui/AppwriteTreeItemBase';
+import { FunctionTreeItem } from '../FunctionTreeItem';
+import { TagTreeItem } from './TagTreeItem';
+
+export class TagsTreeItem extends AppwriteTreeItemBase<FunctionTreeItem> {
+    constructor(public readonly parent: FunctionTreeItem) {
+        super(parent, "Tags");
+    }
+
+    public async getChildren(): Promise<TreeItem[]> {
+        if (!functionsClient) {
+            return [];
+        }
+        const tags = await functionsClient.listTags(this.parent.func.$id);
+        const children = tags?.tags.sort((a, b) => b.dateCreated - a.dateCreated).map((tag) => new TagTreeItem(this, tag)) ?? [new TreeItem('No tags.')];
+
+        if (children.length === 0) {
+            const noTagsItem: TreeItem = {
+                command: {
+                    command: "vscode-appwrite.CreateTag",
+                    title: "Create tag",
+                    arguments: [this],
+                    tooltip: "Create a tag"
+                },
+                label: "Create a tag",
+                iconPath: new ThemeIcon("cloud-upload"),
+            };
+            children.push(noTagsItem);
+        }
+        return children;
+    }
+
+    collapsibleState = TreeItemCollapsibleState.Collapsed;
+
+    contextValue = "tags";
+
+    iconPath = new ThemeIcon("tag");
+}
--- a/src/tree/health/HealthTreeItemProvider.ts
+++ b/src/tree/health/HealthTreeItemProvider.ts
@ -6,6 +6,7 @@ import * as dayjs from "dayjs";
 import * as localizedFormat from "dayjs/plugin/localizedFormat";
 import { healthTooltips } from "../../appwrite/Health";
 import { AppwriteHealth } from "../../appwrite";
+import { promiseWithTimeout } from "../../utils/promiseWithTimeout";
 // dayjs.extend(relativeTime);
 dayjs.extend(localizedFormat);

@ -27,25 +28,42 @@ export class HealthTreeItemProvider implements vscode.TreeDataProvider<vscode.Tr
    }

    async getChildren(element?: HealthTreeItem): Promise<vscode.TreeItem[]> {
-
        if (healthClient === undefined) {
            return [];
        }

        // get children for root
        if (element === undefined) {
-            const health = await healthClient.checkup();
-            ext.outputChannel?.append(JSON.stringify(health, null, 4));
-            const healthItems = Object.entries(health).map(([service, status]) => {
-                return new HealthTreeItem(service, status, healthTooltips[service as keyof AppwriteHealth]);
-            });
-            this.lastChecked = new Date();
-            return [
-                {
-                    label: `Updated at ${dayjs(this.lastChecked).format("LTS")}`,
-                },
-                ...healthItems,
-            ];
+            try {
+                const health = await promiseWithTimeout<Partial<AppwriteHealth> | undefined>(
+                    10000,
+                    async () => {
+                        try {
+                            return await healthClient?.checkup();
+                        } catch (e) {
+                            ext.outputChannel?.append('Error: ' + e.message);
+                            vscode.window.showErrorMessage('Could not connect to Appwrite project');
+                        }
+                    },
+                    "Health request timed out"
+                );
+                if (health === undefined) {
+                    return [];
+                }
+                ext.outputChannel?.append(JSON.stringify(health, null, 4));
+                const healthItems = Object.entries(health).map(([service, status]) => {
+                    return new HealthTreeItem(service, status, healthTooltips[service as keyof AppwriteHealth]);
+                });
+                this.lastChecked = new Date();
+                return [
+                    {
+                        label: `Updated at ${dayjs(this.lastChecked).format("LTS")}`,
+                    },
+                    ...healthItems,
+                ];
+            } catch (e) {
+                //
+            }
        }
        return [];
    }
--- a/src/ui/AddProjectWizard.ts
+++ b/src/ui/AddProjectWizard.ts
@ -1,38 +1,54 @@
 import { window } from "vscode";
-import { AppwriteProjectConfiguration } from "../settings";
+import { AppwriteProjectConfiguration, getActiveProjectConfiguration } from "../settings";

 export async function addProjectWizard(): Promise<AppwriteProjectConfiguration | undefined> {
+    const config = await getActiveProjectConfiguration();
    const endpoint = await window.showInputBox({
        placeHolder: "Endpoint",
-        prompt: "Enter your Appwrite API endping",
-        ignoreFocusOut: true
+        value: config?.endpoint ?? "https://localhost/v1",
+        valueSelection: undefined,
+        prompt: "Enter your Appwrite API endpoint (ex: https://localhost/v1)",
+        ignoreFocusOut: true,
    });
    if (endpoint === undefined) {
        return;
    }
    const projectId = await window.showInputBox({
        placeHolder: "Project Id",
-        prompt: "Enter your Appwrite project id",
-        ignoreFocusOut: true
+        prompt: "Enter your Appwrite project id (ex: 5df5acd0d48c2)",
+        ignoreFocusOut: true,
    });
    if (projectId === undefined) {
        return;
    }
    const secret = await window.showInputBox({
        placeHolder: "API key secret",
-        prompt: "Enter your Appwrite API key secret",
-        ignoreFocusOut: true
+        prompt: "Enter your Appwrite API key secret (with all scopes)",
+        ignoreFocusOut: true,
    });
    if (secret === undefined) {
        return;
    }
+    const selfSigned = await window.showQuickPick(
+        [
+            { label: "Yes", description: "If running Appwrite on localhost, or local IP" },
+            { label: "No", description: "If connecting to a remote Appwrite instance" },
+        ],
+        {
+            placeHolder: "Allow communication with self-signed SSL certificates? (Select 'Yes' for connecting to Appwrite on localhost)",
+            ignoreFocusOut: true,
+        }
+    );
+    if (selfSigned === undefined) {
+        return;
+    }
    const nickname = await window.showInputBox({
        prompt: "(Optional) Project name",
-        ignoreFocusOut: true
+        ignoreFocusOut: true,
    });

    if (endpoint && projectId && secret) {
-        return { endpoint, projectId, secret, nickname };
+        return { endpoint, projectId, secret, nickname, selfSigned: selfSigned.label === "Yes" };
    }
    return undefined;
 }
--- a/src/ui/AppwriteTreeItemBase.ts
+++ b/src/ui/AppwriteTreeItemBase.ts
@ -7,4 +7,7 @@ export abstract class AppwriteTreeItemBase<Parent = void> extends TreeItem {

    abstract getChildren?(): Promise<TreeItem[]>;

+    viewMore(): Promise<void> {
+        return Promise.resolve();
+    }
 }
--- a/src/ui/createRuleWizard.ts
+++ b/src/ui/createRuleWizard.ts
@ -1,42 +1,19 @@
 import { QuickPickItem, window } from "vscode";
+import { Collection, CollectionsList } from "../appwrite";
+import { client } from "../client";
+import { AppwriteSDK } from "../constants";
+import AppwriteCall from "../utils/AppwriteCall";

 export type CreateRuleWizardContext = {
    label: string;
    key: string;
    type: keyof typeof ruleTypes;
+    default: any;
+    required: boolean;
+    array: boolean;
+    list?: string[];
 };

-export async function createRuleWizard(): Promise<CreateRuleWizardContext | undefined> {
-    const label = await window.showInputBox({
-        placeHolder: "Label",
-        prompt: "Attribute internal display name",
-    });
-    if (label === undefined) {
-        return;
-    }
-    const key = await window.showInputBox({
-        placeHolder: "Key",
-        prompt: "Attribute key name. Used as the document JSON key in the Database API.",
-    });
-    if (key === undefined) {
-        return;
-    }
-    const ruleTypeItems: QuickPickItem[] = Object.entries(ruleTypes).map(([label, description]) => ({
-        label,
-        description,
-    }));
-
-    const type = await window.showQuickPick(ruleTypeItems);
-
-    if (type === undefined) {
-        return;
-    }
-    if (label && key && type) {
-        return { label, key, type: (type.label as unknown) as keyof typeof ruleTypes };
-    }
-    return undefined;
-}
-
 const ruleTypes = {
    text: "Any string value.",
    numeric: "Any integer or float value.",
@ -45,6 +22,119 @@ const ruleTypes = {
    url: "Any valid URL.",
    email: "Any valid email address.",
    ip: "Any valid IP v4 or v6 address.",
-    document:
-        "Accept a valid child document. When using this type you are also required to pass the 'list' parameter with an array of the collections UID values of the document types you want to accept.",
+    document: "Accept a valid child document from specified collection(s).",
 };
+
+type RuleType = keyof typeof ruleTypes;
+
+export async function createRuleWizard(collection: Collection): Promise<CreateRuleWizardContext | undefined> {
+    const label = await window.showInputBox({
+        placeHolder: "Attribute label",
+        prompt: "Attribute internal display name",
+        validateInput: (value) => {
+            if (value === "") {
+                return "Label cannot be empty.";
+            }
+        },
+    });
+    if (label === undefined) {
+        return;
+    }
+    const key = await window.showInputBox({
+        placeHolder: "Attribute key name",
+        prompt: "Attribute key name. Used as the document JSON key in the Database API.",
+        ignoreFocusOut: true,
+        validateInput: (value) => {
+            if (value === "") {
+                return "Key name cannot be empty.";
+            }
+        },
+    });
+    if (key === undefined) {
+        return;
+    }
+    const ruleTypeItems: QuickPickItem[] = Object.entries(ruleTypes).map(([label, description]) => ({
+        label,
+        detail: description,
+    }));
+
+    const typeItem = await window.showQuickPick(ruleTypeItems, { placeHolder: "Rule value type." });
+    const type: RuleType | undefined = (typeItem?.label as RuleType) ?? undefined;
+
+    if (typeItem === undefined || type === undefined) {
+        return;
+    }
+
+    let list: string[] | undefined = undefined;
+
+    if (type === "document") {
+        const databaseSdk = new AppwriteSDK.Database(client);
+        const collectionsList = await AppwriteCall<CollectionsList, CollectionsList>(databaseSdk.listCollections());
+
+        if (collectionsList === undefined) {
+            window.showErrorMessage("Could not get collections list.");
+            return;
+        }
+
+        if (collectionsList) {
+            const collections = collectionsList.collections.filter((c) => c.$id !== collection.$id);
+            const qpItems: QuickPickItem[] = collections.map((collection) => ({
+                label: collection.name,
+                description: collection.$id,
+            }));
+
+            const listInput = await window.showQuickPick(qpItems, {
+                canPickMany: true,
+                placeHolder: "Collections which contain valid child documents for this document attribute.",
+                ignoreFocusOut: true,
+            });
+            list = listInput?.map((item) => item.description as string) ?? [];
+        }
+    }
+
+    if (label === "document" && list === undefined) {
+        return;
+    }
+
+    const array = await window.showQuickPick(["Primitive", "Array"], {
+        placeHolder: "Decide if this rule is a primitive or an array of values.",
+        ignoreFocusOut: true,
+    });
+
+    if (array === undefined) {
+        return;
+    }
+
+    const required = await window.showQuickPick(["Required", "Optional"], {
+        placeHolder: "Decide if this rule value is required in order to pass document validation.",
+        ignoreFocusOut: true,
+    });
+
+    if (required === undefined) {
+        return;
+    }
+
+    const defaultValue = await window.showInputBox({
+        placeHolder: "Default value (press Enter to skip)",
+        prompt: "Default value for this rule type. Make sure that the default value is able to pass validation in order to avoid errors when skipping optional values.",
+        ignoreFocusOut: true,
+    });
+
+    if (defaultValue === undefined) {
+        return;
+    }
+
+    if (label && key && type) {
+        return {
+            label,
+            key,
+            type,
+            default: defaultValue,
+            array: array === "Array",
+            required: required === "Required",
+            list,
+        };
+    }
+
+    return undefined;
+}
--- a/src/utils/AppwriteCall.ts
+++ b/src/utils/AppwriteCall.ts
@ -10,7 +10,7 @@ export default function AppwriteCall<T, R = T>(
 ): Promise<R | undefined> {
    return promise.then(
        (successResp) => {
-            ext.outputChannel?.appendLog("Appwrite call success");
+            ext.outputChannel?.appendLog(`Appwrite call success:`);
            if (onSuccess) {
                return onSuccess((successResp as unknown) as T);
            }
--- a/src/utils/date.ts
+++ b/src/utils/date.ts
@ -0,0 +1,9 @@
+import dayjs = require("dayjs");
+import utc = require("dayjs/plugin/utc");
+import timezone = require("dayjs/plugin/timezone"); // dependent on utc plugin
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+export function msToDate(ms: number): string {
+    return dayjs(ms * 1000).tz(dayjs.tz.guess()).format("LTS");
+}
--- a/src/utils/promiseWithTimeout.ts
+++ b/src/utils/promiseWithTimeout.ts
@ -0,0 +1,13 @@
+import { window } from 'vscode';
+
+export const promiseWithTimeout = <T>(timeoutMs: number, promise: () => Promise<T>, failureMessage?: string): Promise<T> => {
+    let timeoutHandle: NodeJS.Timeout;
+    const timeoutPromise = new Promise<never>(() => {
+        timeoutHandle = setTimeout(() => window.showErrorMessage(failureMessage ?? 'Request timed out'), timeoutMs);
+    });
+
+    return Promise.race([promise(), timeoutPromise]).then((result) => {
+        clearTimeout(timeoutHandle);
+        return result;
+    });
+};
--- a/src/utils/sleep.ts
+++ b/src/utils/sleep.ts
@ -0,0 +1,5 @@
+export function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
--- a/src/utils/tar.ts
+++ b/src/utils/tar.ts
@ -0,0 +1,34 @@
+import tar = require("tar");
+import { Uri, window, workspace } from "vscode";
+import { ext } from "../extensionVariables";
+import * as path from "path";
+import * as fs from "fs";
+import { sleep } from './sleep';
+
+export async function getTarReadStream(folder: Uri): Promise<string | undefined> {
+    try {
+        const folderName = path.basename(folder.path);
+
+        const tarName = `${folderName}.tar.gz`;
+        const cwd = path.resolve(folder.fsPath, '..');
+        if (cwd === undefined) {
+            window.showErrorMessage("No workspace open.");
+            return;
+        }
+
+        ext.outputChannel.appendLog(`Creating '${tarName}' in '${workspace.workspaceFolders?.[0].uri.fsPath}'...`);
+        const tarFilePath = path.join(ext.context?.globalStorageUri.fsPath ?? '', tarName);
+        await workspace.fs.createDirectory(ext.context.globalStorageUri);
+
+        tar.create({ gzip: true, cwd: cwd, mode: 1777 }, [path.relative(cwd, folder.fsPath)]).pipe(fs.createWriteStream(tarFilePath));
+
+        await sleep(500);
+
+        ext.outputChannel.appendLog(`Created ${tarFilePath}`);
+
+        return tarFilePath;
+
+    } catch (e) {
+        ext.outputChannel?.appendLog("Error creating tar.gz: " + e);
+    }
+}
--- a/src/utils/types.d.ts
+++ b/src/utils/types.d.ts
@ -0,0 +1,6 @@
+import { Progress } from 'vscode';
+
+export type ProgressMessage = Progress<{
+    message?: string | undefined;
+    increment?: number | undefined;
+}>;
--- a/src/utils/validation.ts
+++ b/src/utils/validation.ts
--- a/src/utils/workspace.ts
+++ b/src/utils/workspace.ts
@ -0,0 +1,84 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as path from "path";
+import * as vscode from "vscode";
+import { QuickPickItem } from 'vscode';
+
+export interface IAzureQuickPickItem<T = undefined> extends QuickPickItem {
+    /**
+     * An optional id to uniquely identify this item across sessions, used in persisting previous selections
+     * If not specified, a hash of the label will be used
+     */
+    id?: string;
+
+    data: T;
+
+    /**
+     * Callback to use when this item is picked, instead of returning the pick
+     * Only applies when used as part of an `AzureWizard`
+     * This is not compatible with `canPickMany`
+     */
+    onPicked?: () => void | Promise<void>;
+
+    /**
+     * The group that this pick belongs to. Set `IAzureQuickPickOptions.enableGrouping` for this property to take effect
+     * Only applies when used as part of an `AzureWizard`
+     */
+    group?: string;
+
+    /**
+     * Optionally used to suppress persistence for this item, defaults to `false`
+     */
+    suppressPersistence?: boolean;
+}
+
+
+export async function selectWorkspaceFolder(placeHolder: string): Promise<string> {
+    return await selectWorkspaceItem(placeHolder, {
+        canSelectFiles: false,
+        canSelectFolders: true,
+        canSelectMany: false,
+        defaultUri:
+            vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0
+                ? vscode.workspace.workspaceFolders[0].uri
+                : undefined,
+        openLabel: "Select",
+    });
+}
+
+export async function selectWorkspaceFile(placeHolder: string, fileExtensions?: string[]): Promise<string> {
+    const filters: { [name: string]: string[] } = {};
+    if (fileExtensions) {
+        filters.Artifacts = fileExtensions;
+    }
+    return await selectWorkspaceItem(placeHolder, {
+        canSelectFiles: true,
+        canSelectFolders: false,
+        canSelectMany: false,
+        openLabel: "Select",
+        filters: filters,
+    });
+}
+
+export async function selectWorkspaceItem(placeHolder: string, options: vscode.OpenDialogOptions): Promise<string> {
+    let folder: IAzureQuickPickItem<string | undefined> | undefined;
+    if (vscode.workspace.workspaceFolders) {
+        const folderPicks: IAzureQuickPickItem<string | undefined>[] = await Promise.all(
+            vscode.workspace.workspaceFolders.map((f: vscode.WorkspaceFolder) => {
+                return { label: path.basename(f.uri.fsPath), description: f.uri.fsPath, data: f.uri.fsPath };
+            })
+        );
+
+        folderPicks.push({ label: "$(file-directory) Browse...", description: "", data: undefined });
+        folder = await vscode.window.showQuickPick(folderPicks, { placeHolder });
+    }
+
+    if (folder?.data) {
+        return folder.data;
+    } else {
+        return (await vscode.window.showOpenDialog(options))?.[0].fsPath ?? '';
+    }
+}
Author	SHA1	Message	Date
Alex Weininger	8b286657b0	Update bug.yaml	2021-08-18 17:41:48 -07:00
Alex Weininger	6a2fbb956b	Update bug.yaml	2021-08-18 17:41:22 -07:00
Alex Weininger	f9d42ad703	Update bug.yaml	2021-08-18 17:40:59 -07:00
Alex Weininger	e76dbc9e89	Create bug.yaml	2021-08-18 17:25:27 -07:00
alexweininger	883893aaab	Fixup	2021-06-17 16:55:43 -07:00
Alex Weininger	47c405a9f5	Add setting to format json strings when viewing a document (#22 ) * Add setting to format json strings when viewing a document * Update changelog	2021-06-17 16:49:08 -07:00
alexweininger	2e77f93759	Fixup changelog	2021-06-03 07:21:04 -07:00
alexweininger	98a132fdef	Update changelog	2021-06-03 07:14:15 -07:00
Alex Weininger	704bd72420	Able to set all collection properties when creating (#21 ) * Able to set all collection properties when creating * Update CHANGELOG.md	2021-06-03 07:12:21 -07:00
alexweininger	60a510b646	Update Readme	2021-05-31 01:50:55 -05:00
alexweininger	6bcbf57143	Change readme image sizes	2021-05-31 01:49:43 -05:00
alexweininger	ac466375e5	Update readme with functions feature images	2021-05-31 01:45:03 -05:00
alexweininger	bdff542ef9	update CI	2021-05-31 01:29:41 -05:00
alexweininger	38273dac92	Bump version, update changelog	2021-05-31 01:28:46 -05:00
Alex Weininger	185e1a98f4	Create function tags (#19 ) * Basic functions create tag and create execution feature * Detailed function support, create tag still broken * create tag and pick folder * edit changelog and bump extension version * fix linting * function tag creation * Create function tags * Fix linting	2021-05-31 01:24:51 -05:00
Alex Weininger	9da0e1ff61	Fix error when deleting user (#18 )	2021-05-31 01:16:29 -05:00
dependabot[bot]	6d6602b872	Bump browserslist from 4.16.4 to 4.16.6 (#16 ) Bumps [browserslist](https://github.com/browserslist/browserslist) from 4.16.4 to 4.16.6. - [Release notes](https://github.com/browserslist/browserslist/releases) - [Changelog](https://github.com/browserslist/browserslist/blob/main/CHANGELOG.md) - [Commits](https://github.com/browserslist/browserslist/compare/4.16.4...4.16.6) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-05-29 20:16:48 -05:00
Alex Weininger	6cbf15379c	Feature: functions (#15 ) * Basic functions create tag and create execution feature * Detailed function support, create tag still broken * create tag and pick folder * edit changelog and bump extension version * fix linting	2021-05-29 10:32:38 -05:00
alexweininger	b4e5fdcd20	Add some flare to the readme, remove temp fix	2021-05-22 00:17:08 -07:00
alexweininger	cf36de1ffb	Temporary fix for Appwrite issue https://github.com/appwrite/appwrite/issues/1171	2021-05-21 00:40:14 -07:00
alexweininger	974691b538	0.0.7 release prep	2021-05-14 13:55:17 -07:00
alexweininger	e5645044d7	remove azure pipeline	2021-05-14 13:52:07 -07:00
alexweininger	747c8bfded	Update gh action	2021-05-14 13:48:43 -07:00
Alex Weininger	226a2f6201	Update ciBuild.yml	2021-05-14 13:46:07 -07:00
Alex Weininger	273f8c5b02	Update CHANGELOG.md	2021-05-14 13:41:36 -07:00
Alex Weininger	797b3d74ec	Show nicer message when Appwrite project can't be found (#14 ) * Show nicer message when Appwrite project can't be found * fix lint errors	2021-05-14 13:00:10 -07:00
Alex Weininger	f8494fa268	Update package.yml for Azure Pipelines	2021-05-08 01:13:51 -07:00
alexweininger	2cf48e1700	Add vsce as a dev dependency	2021-05-08 01:11:29 -07:00
Alex Weininger	a731852e29	Update package.yml for Azure Pipelines	2021-05-08 01:09:16 -07:00
Alex Weininger	472d37dd0c	Set up CI with Azure Pipelines [skip ci]	2021-05-08 01:07:11 -07:00
Alex Weininger	7190b769f8	Fix user password validation when creating a new user (#13 ) * Fix password validation for creating a new user. Must be between 6 and 32 chars inclusive. * update changelog	2021-05-03 14:39:17 -07:00
Alex Weininger	5fa1a5e661	Allow users to specify communication with self-signed certificates to fix connection to Appwrite on local machine (#10 ) * fix self signed certs * add health request time out of 10 seconds	2021-04-30 05:18:12 -07:00
Alex Weininger	4886416bae	bump version (#8 )	2021-04-30 02:58:45 -07:00