appwrite-cli 0.14.0

package/lib/config.js

@@ -0,0 +1,264 @@
+const os = require('os');
+const fs = require("fs");
+const _path = require("path");
+const process = require("process");
+
+class Config {
+    constructor(path) {
+        this.path = path;
+        this.read();
+    }
+
+    read() {
+        try {
+            this.data = require(this.path);
+        } catch (e) {
+            // console.log(`${this.path} not found. Empty data`);
+            this.data = {};
+        }
+    }
+
+    write() {
+        let dir = _path.dirname(this.path)
+        if (!fs.existsSync(dir)){
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(this.path, JSON.stringify(this.data, null, 4));
+    }
+
+    get(key) {
+        return this.data[key];
+    }
+
+    set(key, value) {
+        this.data[key] = value;
+        this.write();
+    }
+
+    delete(key) {
+        delete this.data[key];
+        this.write();
+    }
+
+    clear() {
+        this.data = {};
+        this.write();
+    }
+
+    has(key) {
+        return this.data.hasOwnProperty(key);
+    }
+
+    keys() {
+        return Object.keys(this.data);
+    }
+
+    values() {
+        return Object.values(this.data);
+    }
+
+    toString() {
+        return JSON.stringify(this.data, null, 4);
+    }
+}
+
+class Local extends Config {
+    static CONFIG_FILE_PATH = "appwrite.json";
+
+    constructor(path = Local.CONFIG_FILE_PATH) {
+        let absolutePath = `${process.cwd()}/${path}`;
+        super(absolutePath);
+    }
+
+    getFunctions() {
+        if (!this.has("functions")) {
+            return [];
+        }
+        return this.get("functions");
+    }
+
+    getFunction($id) {
+        if (!this.has("functions")) {
+            return {};
+        }
+
+        let functions = this.get("functions");
+        for (let i = 0; i < functions.length; i++) {
+            if (functions[i]['$id'] == $id) {
+                return functions[i];
+            }
+        }
+
+        return {};
+    }
+
+    addFunction(props) {
+        if (!this.has("functions")) {
+            this.set("functions", []);
+        }
+
+        let functions = this.get("functions");
+        for (let i = 0; i < functions.length; i++) {
+            if (functions[i]['$id'] == props['$id']) {
+                return;
+            }
+        }
+        functions.push(props);
+        this.set("functions", functions);
+    }
+
+    updateFunction(id, props) {
+        if (!this.has("functions")) {
+            return;
+        }
+
+        let functions = this.get("functions");
+        for (let i = 0; i < functions.length; i++) {
+            if (functions[i]['$id'] == id) {
+                functions[i] = {
+                    ...functions[i],
+                    ...props
+                };
+                this.set("functions", functions);
+                return;
+            }
+        }
+    }
+
+    getCollections() {
+        if (!this.has("collections")) {
+            return [];
+        }
+        return this.get("collections");
+    }
+
+    getCollection($id) {
+        if (!this.has("collection")) {
+            return {};
+        }
+
+        let collections = this.get("collections");
+        for (let i = 0; i < collections.length; i++) {
+            if (collections[i]['$id'] == $id) {
+                return collections[i];
+            }
+        }
+
+        return {};
+    }
+
+    addCollection(props) {
+        if (!this.has("collections")) {
+            this.set("collections", []);
+        }
+
+        let collections = this.get("collections");
+        for (let i = 0; i < collections.length; i++) {
+            if (collections[i]['$id'] == props['$id']) {
+                collections[i] = props;
+                this.set("collections", collections);
+                return;
+            }
+        }
+        collections.push(props);
+        this.set("collections", collections);
+    }
+
+    getProject() {
+        if (!this.has("projectId") || !this.has("projectName")) {
+            return {};
+        }
+
+        return {
+            projectId: this.get("projectId"),
+            projectName: this.get("projectName"),
+        };
+    }
+
+    setProject(projectId, projectName) {
+        this.set("projectId", projectId);
+        this.set("projectName", projectName);
+    }
+}
+
+class Global extends Config {
+    static CONFIG_FILE_PATH = ".appwrite/prefs.json";
+
+    static PREFERENCE_ENDPOINT = "endpoint";
+    static PREFERENCE_SELF_SIGNED = "selfSigned";
+    static PREFERENCE_COOKIE = "cookie";
+    static PREFERENCE_PROJECT = "project";
+    static PREFERENCE_KEY = "key";
+    static PREFERENCE_LOCALE = "locale";
+    static PREFERENCE_MODE = "mode";
+
+    static MODE_ADMIN = "admin";
+    static MODE_DEFAULT = "default";
+
+    static PROJECT_CONSOLE = "console";
+
+    constructor(path = Global.CONFIG_FILE_PATH) {
+        const homeDir = os.homedir();
+        super(`${homeDir}/${path}`);
+    }
+
+    getEndpoint() {
+        if (!this.has(Global.PREFERENCE_ENDPOINT)) {
+            return "";
+        }
+        return this.get(Global.PREFERENCE_ENDPOINT);
+    }
+
+    setEndpoint(endpoint) {
+        this.set(Global.PREFERENCE_ENDPOINT, endpoint);
+    }
+
+    getSelfSigned() {
+        if (!this.has(Global.PREFERENCE_SELF_SIGNED)) {
+            return false;
+        }
+        return this.get(Global.PREFERENCE_SELF_SIGNED);
+    }
+
+    setSelfSigned(selfSigned) {
+        this.set(Global.PREFERENCE_SELF_SIGNED, selfSigned);
+    }
+
+    getCookie() {
+        if (!this.has(Global.PREFERENCE_COOKIE)) {
+            return "";
+        }
+        return this.get(Global.PREFERENCE_COOKIE);
+    }
+
+    setCookie(cookie) {
+        this.set(Global.PREFERENCE_COOKIE, cookie);
+    }
+
+    getProject() {
+        if (!this.has(Global.PREFERENCE_PROJECT)) {
+            return "";
+        }
+        return this.get(Global.PREFERENCE_PROJECT);
+    }
+
+    setProject(project) {
+        this.set(Global.PREFERENCE_PROJECT, project);
+    }
+
+    getKey() {
+        if (!this.has(Global.PREFERENCE_KEY)) {
+            return "";
+        }
+        return this.get(Global.PREFERENCE_KEY);
+    }
+
+    setKey(key) {
+        this.set(Global.PREFERENCE_KEY, key);
+    }
+}
+
+module.exports = {
+    localConfig : new Local(),
+    globalConfig : new Global(),
+};

package/lib/exception.js

@@ -0,0 +1,9 @@
+class AppwriteException extends Error {
+  constructor(message, code, response) {
+    super(message);
+    this.code = code;
+    this.response = response;
+  }
+}
+
+module.exports = AppwriteException;

package/lib/parser.js

@@ -0,0 +1,179 @@
+const chalk = require('chalk');
+const commander = require('commander');
+const Table = require('cli-table3');
+const { description } = require('../package.json');
+
+const cliConfig = {
+  verbose: false,
+  json: false
+};
+
+const parse = (data) => {
+    if (cliConfig.json) {
+        drawJSON(data);
+        return;
+    }
+
+    for (let key in data) {
+        if (Array.isArray(data[key])) {
+            console.log(`${chalk.yellow.bold.underline(key)}`);
+            if (typeof data[key][0] === 'object') {
+                drawTable(data[key]);
+            } else {
+                drawJSON(data[key]);
+            }
+        } else if (typeof data[key] === 'object') {
+            console.log(`${chalk.yellow.bold.underline(key)}`)
+            parse(data[key]);
+        } else {
+            console.log(`${chalk.yellow.bold(key)} : ${data[key]}`);
+        }
+    }
+}
+
+const drawTable = (data) => {
+    if (data.length == 0) {
+        console.log("[]")
+        return;
+    }
+
+    // Create an object with all the keys in it
+    let obj = data.reduce((res, item) => ({ ...res, ...item }));
+    // Get those keys as an array
+    let keys = Object.keys(obj);
+    // Create an object with all keys set to the default value ''
+    let def = keys.reduce((result, key) => {
+        result[key] = '-'
+        return result;
+    }, {});
+    // Use object destrucuring to replace all default values with the ones we have
+    data = data.map((item) => ({ ...def, ...item }));
+
+    let columns = Object.keys(data[0]);
+
+    let table = new Table({
+        head: columns.map(c => chalk.cyan.italic.bold(c)),
+        chars: {
+            'top': ' ',
+            'top-mid': ' ',
+            'top-left': ' ',
+            'top-right': ' ',
+            'bottom': ' ',
+            'bottom-mid': ' ',
+            'bottom-left': ' ',
+            'bottom-right': ' ',
+            'left': ' ',
+            'left-mid': ' ',
+            'mid': chalk.cyan('─'),
+            'mid-mid': chalk.cyan('┼'),
+            'right': ' ',
+            'right-mid': ' ',
+            'middle': chalk.cyan('│')
+        }
+    });
+
+    data.forEach(row => {
+        let rowValues = [];
+        for (let key in row) {
+            if (row[key] === null) {
+                rowValues.push("-");
+            } else if (Array.isArray(row[key])) {
+                switch (row[key].length) {
+                    case 1:
+                        if (typeof row[key][0] === 'object') {
+                            rowValues.push(`array(${row[key].length})`);
+                        } else {
+                            rowValues.push(row[key][0]);
+                        }
+                        break;
+                    default:
+                        rowValues.push(`array(${row[key].length})`);
+                        break;
+                }
+            } else if (typeof row[key] === 'object') {
+                rowValues.push("object");
+            } else {
+                rowValues.push(row[key]);
+            }
+        }
+        table.push(rowValues);
+    });
+    console.log(table.toString());
+}
+
+const drawJSON = (data) => {
+    console.log(JSON.stringify(data, null, 2));
+}
+
+const parseError = (err) => {
+    if(cliConfig.verbose) {
+        console.error(err);
+    }
+
+    error(err.message);
+
+    process.exit(1)
+}
+
+const actionRunner = (fn) => {
+    return (...args) => fn(...args).catch(parseError);
+}
+
+const parseInteger = (value) => {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new commander.InvalidArgumentError('Not a number.');
+    }
+    return parsedValue;
+}
+
+const parseBool = (value) => {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    throw new commander.InvalidArgumentError('Not a boolean.');
+}
+
+const log = (message) => {
+    console.log(`${chalk.cyan.bold("ℹ Info")} ${chalk.cyan(message ?? "")}`);
+}
+
+const success = (message) => {
+    console.log(`${chalk.green.bold("✓ Success")} ${chalk.green(message ?? "")}`);
+}
+
+const error = (message) => {
+    console.error(`${chalk.red.bold("✗ Error")} ${chalk.red(message ?? "")}`);
+}
+
+const logo = "\n    _                            _ _           ___   __   _____ \n   \/_\\  _ __  _ ____      ___ __(_) |_ ___    \/ __\\ \/ \/   \\_   \\\n  \/\/_\\\\| '_ \\| '_ \\ \\ \/\\ \/ \/ '__| | __\/ _ \\  \/ \/   \/ \/     \/ \/\\\/\n \/  _  \\ |_) | |_) \\ V  V \/| |  | | ||  __\/ \/ \/___\/ \/___\/\\\/ \/_  \n \\_\/ \\_\/ .__\/| .__\/ \\_\/\\_\/ |_|  |_|\\__\\___| \\____\/\\____\/\\____\/  \n       |_|   |_|                                                \n\n";
+
+const commandDescriptions = {
+    "account": `The account command allows you to authenticate and manage a user account.`,
+    "avatars": `The avatars command aims to help you complete everyday tasks related to your app image, icons, and avatars.`,
+    "database": `The database command allows you to create structured collections of documents, query and filter lists of documents.`,
+    "deploy": `The deploy command provides a convenient wrapper for deploying your functions and collections.`,
+    "functions": `The functions command allows you view, create and manage your Cloud Functions.`,
+    "health": `The health command allows you to both validate and monitor your Appwrite server's health.`,
+    "init": `The init command helps you initialize your Appwrite project, functions and collections`,
+    "locale": `The locale command allows you to customize your app based on your users' location.`,
+    "projects": `The projects command allows you to view, create and manage your Appwrite projects.`,
+    "storage": `The storage command allows you to manage your project files.`,
+    "teams": `The teams command allows you to group users of your project and to enable them to share read and write access to your project resources`,
+    "users": `The users command allows you to manage your project users.`,
+    "client": `The client command allows you to configure your CLI`,
+    "login": `The login command allows you to authenticate and manage a user account.`,
+    "logout": `The logout command allows you to logout of your Appwrite account.`,
+    "main": chalk.redBright(`${logo}${description}`),
+}
+
+module.exports = {
+    parse,
+    actionRunner,
+    parseInteger,
+    parseBool,
+    log,
+    success,
+    error,
+    commandDescriptions,
+    cliConfig
+}

package/lib/questions.js

@@ -0,0 +1,223 @@
+const { localConfig } = require('./config');
+const { projectsList } = require('./commands/projects');
+const { functionsListRuntimes } = require('./commands/functions');
+
+const getEntrypoint = (runtime) => {
+  const languge = runtime.split('-')[0];
+
+  switch (languge) {
+    case 'dart':
+      return 'lib/main.dart';
+    case 'deno':
+      return 'src/mod.ts';
+    case 'node':
+      return 'src/index.js';
+    case 'php':
+      return 'src/index.php';
+    case 'python':
+      return 'src/index.py';
+    case 'ruby':
+      return 'src/index.rb';
+    case 'rust':
+      return 'main.rs';
+    case 'swift':
+      return 'Sources/swift-5.5/main.swift';
+  }
+
+  return undefined;
+};
+
+const questionsInitProject = [
+  {
+    type: "confirm",
+    name: "override",
+    message:
+      `An Appwrite project ( ${localConfig.getProject()['projectName']} ) is already associated with the current directory. Would you like to override`,
+    when() {
+      return Object.keys(localConfig.getProject()).length !== 0;
+    }
+  },
+  {
+    type: "list",
+    name: "start",
+    when(answers) {
+      if (answers.override == undefined) {
+        return true 
+      }
+      return answers.override;
+    },
+    message: "How would you like to start?",
+    choices: [
+      {
+        name: "Create a new Appwrite project",
+        value: "new",
+      },
+      {
+        name: "Link this directory to an existing Appwrite project",
+        value: "existing",
+      },
+    ],
+  },
+  {
+    type: "input",
+    name: "project",
+    message: "What would you like to name your project?",
+    default: "My Awesome Project",
+    when(answers) {
+      return answers.start == "new";
+    },
+  },
+  {
+    type: "list",
+    name: "project",
+    message: "Choose your Appwrite project.",
+    when(answers) {
+      return answers.start == "existing";
+    },
+    choices: async () => {
+      let response = await projectsList({
+        parseOutput: false
+      })
+      let projects = response["projects"]
+      let choices = projects.map((project, idx) => {
+        return {
+          name: `${project.name} (${project['$id']})`,
+          value: {
+            name: project.name,
+            id: project['$id']
+          }
+        }
+      })
+
+      if (choices.length == 0) {
+        throw new Error("No projects found. Please create a new project.")
+      }
+
+      return choices;
+    }
+  }
+];
+
+const questionsInitFunction = [
+  {
+    type: "input",
+    name: "name",
+    message: "What would you like to name your function?",
+    default: "My Awesome Function"
+  },
+  {
+    type: "list",
+    name: "runtime",
+    message: "What runtime would you like to use?",
+    choices: async () => {
+      let response = await functionsListRuntimes({
+        parseOutput: false
+      })
+      let runtimes = response["runtimes"]
+      let choices = runtimes.map((runtime, idx) => {
+        return {
+          name: `${runtime.name} (${runtime['$id']})`,
+          value: { id: runtime['$id'], entrypoint: getEntrypoint(runtime['$id'])}
+        }
+      })
+      return choices;
+    }
+  }
+];
+
+const questionsLogin = [
+  {
+    type: "input",
+    name: "email",
+    message: "Enter your email",
+    validate(value) {
+      if (!value) {
+        return "Please enter your email";
+      }
+      return true;
+    },
+  },
+  {
+    type: "password",
+    name: "password",
+    message: "Enter your password",
+    mask: "*",
+    validate(value) {
+      if (!value) {
+        return "Please enter your password";
+      }
+      return true;
+    }
+  },
+];
+
+const questionsDeployFunctions = [
+  {
+    type: "checkbox",
+    name: "functions",
+    message: "Which functions would you like to deploy?",
+    choices: () => {
+      let functions = localConfig.getFunctions();
+      if (functions.length === 0) {
+        throw new Error("No functions found in the current directory.");
+      }
+      let choices = functions.map((func, idx) => {
+        return {
+          name: `${func.name} (${func['$id']})`,
+          value: func
+        }
+      })
+      return choices;
+    }
+  }
+]
+
+const questionsDeployCollections = [
+  {
+    type: "checkbox",
+    name: "collections",
+    message: "Which collections would you like to deploy?",
+    choices: () => {
+      let collections = localConfig.getCollections();
+      if (collections.length === 0) {
+        throw new Error("No collections found in the current directory. Run `appwrite init collection` to fetch all your collections.");
+      }
+      let choices = collections.map((collection, idx) => {
+        return {
+          name: `${collection.name} (${collection['$id']})`,
+          value: collection
+        }
+      })
+      return choices;
+    }
+  },
+  {
+    type: "input",
+    name: "override",
+    message: 'Are you sure you want to override this collection? This can lead to loss of data! Type "YES" to confirm.'
+  },
+]
+
+const questionsGetEntrypoint = [
+  {
+    type: "input",
+    name: "entrypoint",
+    message: "Enter the entrypoint",
+    default: null,
+    validate(value) {
+      if (!value) {
+        return "Please enter your enrtypoint";
+      }
+      return true;
+    }
+  },
+]
+
+module.exports = {
+  questionsInitProject,
+  questionsLogin,
+  questionsInitFunction,
+  questionsDeployFunctions,
+  questionsDeployCollections,
+  questionsGetEntrypoint
+};