appwrite-cli 5.0.5 → 6.0.0-rc.1

package/lib/emulation/docker.js

@@ -0,0 +1,187 @@
+const childProcess = require('child_process');
+const { localConfig } = require("../config");
+const path = require('path');
+const fs = require('fs');
+const { log,success } = require("../parser");
+const { openRuntimesVersion, systemTools } = require("./utils");
+const ID = require("../id");
+
+const activeDockerIds = {};
+
+async function dockerStop(id) {
+    delete activeDockerIds[id];
+    const stopProcess = childProcess.spawn('docker', ['rm', '--force', id], {
+        stdio: 'pipe',
+    });
+
+    await new Promise((res) => { stopProcess.on('close', res) });
+}
+
+async function dockerPull(func) {
+    log('Pulling Docker image of function runtime ...');
+
+    const runtimeChunks = func.runtime.split("-");
+    const runtimeVersion = runtimeChunks.pop();
+    const runtimeName = runtimeChunks.join("-");
+    const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+    const pullProcess = childProcess.spawn('docker', ['pull', imageName], {
+        stdio: 'pipe',
+        pwd: path.join(process.cwd(), func.path)
+    });
+
+    pullProcess.stderr.on('data', (data) => {
+        process.stderr.write(`\n${data}$ `);
+    });
+
+    await new Promise((res) => { pullProcess.on('close', res) });
+}
+
+async function dockerBuild(func, variables) {
+    log('Building function using Docker ...');
+
+    const runtimeChunks = func.runtime.split("-");
+    const runtimeVersion = runtimeChunks.pop();
+    const runtimeName = runtimeChunks.join("-");
+    const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+    const functionDir = path.join(process.cwd(), func.path);
+
+    const id = ID.unique();
+
+    const params = [ 'run' ];
+    params.push('--name', id);
+    params.push('-v', `${functionDir}/:/mnt/code:rw`);
+    params.push('-e', 'APPWRITE_ENV=development');
+    params.push('-e', 'OPEN_RUNTIMES_ENV=development');
+    params.push('-e', 'OPEN_RUNTIMES_SECRET=');
+    params.push('-e', `OPEN_RUNTIMES_ENTRYPOINT=${func.entrypoint}`);
+
+    for(const k of Object.keys(variables)) {
+        params.push('-e', `${k}=${variables[k]}`);
+    }
+
+    params.push(imageName, 'sh', '-c', `helpers/build.sh "${func.commands}"`);
+
+    const buildProcess = childProcess.spawn('docker', params, {
+        stdio: 'pipe',
+        pwd: functionDir
+    });
+
+    buildProcess.stdout.on('data', (data) => {
+        process.stdout.write(`\n${data}`);
+    });
+
+    buildProcess.stderr.on('data', (data) => {
+        process.stderr.write(`\n${data}`);
+    });
+
+    await new Promise((res) => { buildProcess.on('close', res) });
+
+    const copyPath = path.join(process.cwd(), func.path, '.appwrite', 'build.tar.gz');
+    const copyDir = path.dirname(copyPath);
+    if (!fs.existsSync(copyDir)) {
+        fs.mkdirSync(copyDir, { recursive: true });
+    }
+
+    const copyProcess = childProcess.spawn('docker', ['cp', `${id}:/mnt/code/code.tar.gz`, copyPath], {
+        stdio: 'pipe',
+        pwd: functionDir
+    });
+
+    await new Promise((res) => { copyProcess.on('close', res) });
+
+    const cleanupProcess = childProcess.spawn('docker', ['rm', '--force', id], {
+        stdio: 'pipe',
+        pwd: functionDir
+    });
+
+    await new Promise((res) => { cleanupProcess.on('close', res) });
+
+    delete activeDockerIds[id];
+
+    const tempPath = path.join(process.cwd(), func.path, 'code.tar.gz');
+    if (fs.existsSync(tempPath)) {
+        fs.rmSync(tempPath, { force: true });
+    }
+}
+
+async function dockerStart(func, variables, port) {
+   log('Starting function using Docker ...');
+
+   log("Permissions, events, CRON and timeouts dont apply when running locally.");
+
+   log('💡 Hint: Function automatically restarts when you edit your code.');
+
+   success(`Visit http://localhost:${port}/ to execute your function.`);
+
+
+   const runtimeChunks = func.runtime.split("-");
+   const runtimeVersion = runtimeChunks.pop();
+   const runtimeName = runtimeChunks.join("-");
+    const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+    const tool = systemTools[runtimeName];
+
+    const functionDir = path.join(process.cwd(), func.path);
+
+    const id = ID.unique();
+
+    const params = [ 'run' ];
+    params.push('--rm');
+    params.push('-d');
+    params.push('--name', id);
+    params.push('-p', `${port}:3000`);
+    params.push('-e', 'APPWRITE_ENV=development');
+    params.push('-e', 'OPEN_RUNTIMES_ENV=development');
+    params.push('-e', 'OPEN_RUNTIMES_SECRET=');
+
+   for(const k of Object.keys(variables)) {
+        params.push('-e', `${k}=${variables[k]}`);
+    }
+
+    params.push('-v', `${functionDir}/.appwrite/logs.txt:/mnt/logs/dev_logs.log:rw`);
+    params.push('-v', `${functionDir}/.appwrite/errors.txt:/mnt/logs/dev_errors.log:rw`);
+    params.push('-v', `${functionDir}/.appwrite/build.tar.gz:/mnt/code/code.tar.gz:ro`);
+    params.push(imageName, 'sh', '-c', `helpers/start.sh "${tool.startCommand}"`);
+
+    childProcess.spawn('docker', params, {
+        stdio: 'pipe',
+        pwd: functionDir
+    });
+
+    activeDockerIds[id] = true;
+}
+
+async function dockerCleanup() {
+    await dockerStop();
+
+    const functions = localConfig.getFunctions();
+    for(const func of functions) {
+        const appwritePath = path.join(process.cwd(), func.path, '.appwrite');
+        if (fs.existsSync(appwritePath)) {
+            fs.rmSync(appwritePath, { recursive: true, force: true });
+        }
+
+        const tempPath = path.join(process.cwd(), func.path, 'code.tar.gz');
+        if (fs.existsSync(tempPath)) {
+            fs.rmSync(tempPath, { force: true });
+        }
+    }
+}
+
+async function dockerStopActive() {
+    const ids = Object.keys(activeDockerIds);
+    for await (const id of ids) {
+        await dockerStop(id);
+    }
+}
+
+module.exports = {
+    dockerStop,
+    dockerPull,
+    dockerBuild,
+    dockerStart,
+    dockerCleanup,
+    dockerStopActive,
+}

package/lib/emulation/utils.js

@@ -0,0 +1,177 @@
+const EventEmitter = require('node:events');
+const { projectsCreateJWT } = require('../commands/projects');
+const { localConfig } = require("../config");
+
+
+const openRuntimesVersion = 'v3';
+
+const runtimeNames = {
+    'node': 'Node.js',
+    'php': 'PHP',
+    'ruby': 'Ruby',
+    'python': 'Python',
+    'python-ml': 'Python (ML)',
+    'deno': 'Deno',
+    'dart': 'Dart',
+    'dotnet': '.NET',
+    'java': 'Java',
+    'swift': 'Swift',
+    'kotlin': 'Kotlin',
+    'bun': 'Bun'
+};
+
+const systemTools = {
+    'node': {
+        isCompiled: false,
+        startCommand: "node src/server.js",
+        dependencyFiles: [ "package.json", "package-lock.json" ]
+    },
+    'php': {
+        isCompiled: false,
+        startCommand: "php src/server.php",
+        dependencyFiles: [ "composer.json", "composer.lock" ]
+    },
+    'ruby': {
+        isCompiled: false,
+        startCommand: "bundle exec puma -b tcp://0.0.0.0:3000 -e production",
+        dependencyFiles: [ "Gemfile", "Gemfile.lock" ]
+    },
+    'python': {
+        isCompiled: false,
+        startCommand: "python3 src/server.py",
+        dependencyFiles: [ "requirements.txt", "requirements.lock" ]
+    },
+    'python-ml': {
+        isCompiled: false,
+        startCommand: "python3 src/server.py",
+        dependencyFiles: [ "requirements.txt", "requirements.lock" ]
+    },
+    'deno': {
+        isCompiled: false,
+        startCommand: "deno start",
+        dependencyFiles: [ ]
+    },
+    'dart': {
+        isCompiled: true,
+        startCommand: "src/function/server",
+        dependencyFiles: [ ]
+    },
+    'dotnet': {
+        isCompiled: true,
+        startCommand: "dotnet src/function/DotNetRuntime.dll",
+        dependencyFiles: [ ]
+    },
+    'java': {
+        isCompiled: true,
+        startCommand: "java -jar src/function/java-runtime-1.0.0.jar",
+        dependencyFiles: [ ]
+    },
+    'swift': {
+        isCompiled: true,
+        startCommand: "src/function/Runtime serve --env production --hostname 0.0.0.0 --port 3000",
+        dependencyFiles: [ ]
+    },
+    'kotlin': {
+        isCompiled: true,
+        startCommand: "java -jar src/function/kotlin-runtime-1.0.0.jar",
+        dependencyFiles: [ ]
+    },
+    'bun': {
+        isCompiled: false,
+        startCommand: "bun src/server.ts",
+        dependencyFiles: [ "package.json", "package-lock.json", "bun.lockb" ]
+    },
+};
+
+const JwtManager = {
+    userJwt: null,
+    functionJwt: null,
+
+    timerWarn: null,
+    timerError: null,
+
+    async setup(userId = null) {
+        if(this.timerWarn) {
+            clearTimeout(this.timerWarn);
+        }
+
+        if(this.timerError) {
+            clearTimeout(this.timerError);
+        }
+
+        this.timerWarn = setTimeout(() => {
+            log("Warning: Authorized JWT will expire in 5 minutes. Please stop and re-run the command to refresh tokens for 1 hour.");
+        }, 1000 * 60 * 55); // 55 mins
+
+        this.timerError = setTimeout(() => {
+            log("Warning: Authorized JWT just expired. Please stop and re-run the command to obtain new tokens with 1 hour validity.");
+            log("Some Appwrite API communication is not authorized now.")
+        }, 1000 * 60 * 60); // 60 mins
+
+        if(userId) {
+            await usersGet({
+                userId,
+                parseOutput: false
+            });
+            const userResponse = await usersCreateJWT({
+                userId,
+                duration: 60*60,
+                parseOutput: false
+            });
+            this.userJwt = userResponse.jwt;
+        }
+
+        const functionResponse = await projectsCreateJWT({
+            projectId: localConfig.getProject().projectId,
+            // TODO: Once we have endpoint for this, use it
+            scopes: ["sessions.write","users.read","users.write","teams.read","teams.write","databases.read","databases.write","collections.read","collections.write","attributes.read","attributes.write","indexes.read","indexes.write","documents.read","documents.write","files.read","files.write","buckets.read","buckets.write","functions.read","functions.write","execution.read","execution.write","locale.read","avatars.read","health.read","providers.read","providers.write","messages.read","messages.write","topics.read","topics.write","subscribers.read","subscribers.write","targets.read","targets.write","rules.read","rules.write","migrations.read","migrations.write","vcs.read","vcs.write","assistant.read"],
+            duration: 60*60,
+            parseOutput: false
+        });
+        this.functionJwt = functionResponse.jwt;
+    }
+};
+
+const Queue = {
+    files: [],
+    locked: false,
+    events: new EventEmitter(),
+    debounce: null,
+    push(file) {
+        if(!this.files.includes(file)) {
+            this.files.push(file);
+        }
+
+        if(!this.locked) {
+            this._trigger();
+        }
+    },
+    lock() {
+        this.files = [];
+        this.locked = true;
+    },
+    unlock() {
+        this.locked = false;
+        if(this.files.length > 0) {
+            this._trigger();
+        }
+    },
+    _trigger() {
+        if(this.debounce) {
+            return;
+        }
+
+        this.debounce = setTimeout(() => {
+            this.events.emit('reload', { files: this.files });
+            this.debounce = null;
+        }, 300);
+    }
+};
+
+module.exports = {
+    openRuntimesVersion,
+    runtimeNames,
+    systemTools,
+    JwtManager,
+    Queue
+}

package/lib/id.js

@@ -0,0 +1,30 @@
+class ID {
+    // Generate an hex ID based on timestamp
+    // Recreated from https://www.php.net/manual/en/function.uniqid.php
+    static #hexTimestamp() {
+        const now = new Date();
+        const sec = Math.floor(now.getTime() / 1000);
+        const msec = now.getMilliseconds();
+
+        // Convert to hexadecimal
+        const hexTimestamp = sec.toString(16) + msec.toString(16).padStart(5, '0');
+        return hexTimestamp;
+    }
+
+    static custom(id) {
+        return id
+    }
+
+    static unique(padding = 7) {
+        // Generate a unique ID with padding to have a longer ID
+        const baseId = ID.#hexTimestamp();
+        let randomPadding = '';
+        for (let i = 0; i < padding; i++) {
+            const randomHexDigit = Math.floor(Math.random() * 16).toString(16);
+            randomPadding += randomHexDigit;
+        }
+        return baseId + randomPadding;
+    }
+}
+
+module.exports = ID;

package/lib/paginate.js

@@ -5,7 +5,6 @@ const paginate = async (action, args = {}, limit = 100, wrapper = '') => {
 
     while (true) {
         const offset = pageNumber * limit;
-
         // Merge the limit and offset into the args
         const response = await action({
             ...args,
@@ -48,4 +47,4 @@ const paginate = async (action, args = {}, limit = 100, wrapper = '') => {
 
 module.exports = {
     paginate
-};
+};

package/lib/parser.js

@@ -2,10 +2,18 @@ const chalk = require('chalk');
 const commander = require('commander');
 const Table = require('cli-table3');
 const { description } = require('../package.json');
+const { globalConfig } = require("./config.js");
+const os = require('os');
+const Client = require("./client");
 
 const cliConfig = {
-  verbose: false,
-  json: false
+    verbose: false,
+    json: false,
+    force: false,
+    all: false,
+    ids: [],
+    report: false,
+    reportData: {}
 };
 
 const parse = (data) => {
@@ -110,17 +118,60 @@ const drawJSON = (data) => {
 }
 
 const parseError = (err) => {
-    if(cliConfig.verbose) {
-        console.error(err);
-    }
+    if (cliConfig.report) {
+        (async () => {
+            let appwriteVersion = 'unknown';
+            const endpoint = globalConfig.getEndpoint();
+            const isCloud = endpoint.includes('cloud.appwrite.io') ? 'Yes' : 'No';
+
+            try {
+                const client = new Client().setEndpoint(endpoint);
+                const res = await client.call('get', '/health/version');
+                appwriteVersion = res.version;
+            } catch {
+            }
+
+            const version = '6.0.0-rc.1';
+            const stepsToReproduce = `Running \`appwrite ${cliConfig.reportData.data.args.join(' ')}\``;
+            const yourEnvironment = `CLI version: ${version}\nOperation System: ${os.type()}\nAppwrite version: ${appwriteVersion}\nIs Cloud: ${isCloud}`;
+
+            const stack = '```\n' + err.stack + '\n```';
+
+            const githubIssueUrl = new URL('https://github.com/appwrite/appwrite/issues/new');
+            githubIssueUrl.searchParams.append('labels', 'bug');
+            githubIssueUrl.searchParams.append('template', 'bug.yaml');
+            githubIssueUrl.searchParams.append('title', `🐛 Bug Report: ${err.message}`);
+            githubIssueUrl.searchParams.append('actual-behavior', `CLI Error:\n${stack}`);
+            githubIssueUrl.searchParams.append('steps-to-reproduce', stepsToReproduce);
+            githubIssueUrl.searchParams.append('environment', yourEnvironment);
+
+            log(`To report this error you can:\n - Create a support ticket in our Discord server https://appwrite.io/discord \n - Create an issue in our Github\n   ${githubIssueUrl.href}\n`);
 
-    error(err.message);
 
-    process.exit(1)
+            error('\n Stack Trace: \n');
+            console.error(err);
+            process.exit(1);
+        })()
+    } else {
+        if (cliConfig.verbose) {
+            console.error(err);
+        } else {
+            log('For detailed error pass the --verbose or --report flag');
+            error(err.message);
+        }
+        process.exit(1);
+    }
+
 }
 
 const actionRunner = (fn) => {
-    return (...args) => fn(...args).catch(parseError);
+    return (...args) => {
+        if (cliConfig.all && (Array.isArray(cliConfig.ids) && cliConfig.ids.length !== 0)) {
+            error(`The '--all' and '--id' flags cannot be used together.`);
+            process.exit(1);
+        }
+        return fn(...args).catch(parseError)
+    };
 }
 
 const parseInteger = (value) => {
@@ -156,10 +207,12 @@ const commandDescriptions = {
     "graphql": `The graphql command allows you to query and mutate any resource type on your Appwrite server.`,
     "avatars": `The avatars command aims to help you complete everyday tasks related to your app image, icons, and avatars.`,
     "databases": `The databases 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.`,
+    "init": `The init command provides a convenient wrapper for creating and initializing project, functions, collections, buckets, teams and messaging in Appwrite.`,
+    "push": `The push command provides a convenient wrapper for pushing your functions, collections, buckets, teams and messaging.`,
+    "run": `The run command allows you to run project locally to allow easy development and quick debugging.`,
     "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`,
+    "pull": `The pull command helps you pull your Appwrite project, functions, collections, buckets, teams and messaging`,
     "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.`,
@@ -168,6 +221,8 @@ const commandDescriptions = {
     "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.`,
+    "whoami": `The whoami command gives information about the currently logged in user.`,
+    "register": `Outputs the link to create an Appwrite account..`,
     "console" : `The console command allows gives you access to the APIs used by the Appwrite console.`,
     "assistant": `The assistant command allows you to interact with the Appwrite Assistant AI`,
     "messaging": `The messaging command allows you to send messages.`,
@@ -179,6 +234,7 @@ const commandDescriptions = {
 }
 
 module.exports = {
+    drawTable,
     parse,
     actionRunner,
     parseInteger,
@@ -187,5 +243,6 @@ module.exports = {
     success,
     error,
     commandDescriptions,
-    cliConfig
-}
+    cliConfig,
+    drawTable
+}