chirag-appwrite-cli 0.1.0

package/lib/commands/run.js

@@ -0,0 +1,330 @@
+const Tail = require('tail').Tail;
+const { parse: parseDotenv } = require('dotenv');
+const chalk = require('chalk');
+const ignore = require("ignore");
+const tar = require("tar");
+const fs = require("fs");
+const chokidar = require('chokidar');
+const inquirer = require("inquirer");
+const path = require("path");
+const { Command } = require("commander");
+const { localConfig, globalConfig } = require("../config");
+const { paginate } = require('../paginate');
+const { functionsListVariables } = require('./functions');
+const { questionsRunFunctions } = require("../questions");
+const { actionRunner, success, log, warn, error, hint, commandDescriptions, drawTable } = require("../parser");
+const { systemHasCommand, isPortTaken, getAllFiles } = require('../utils');
+const { runtimeNames, systemTools, JwtManager, Queue } = require('../emulation/utils');
+const { dockerStop, dockerCleanup, dockerStart, dockerBuild, dockerPull } = require('../emulation/docker');
+
+const runFunction = async ({ port, functionId, withVariables, reload, userId } = {}) => {
+    // Selection
+    if(!functionId) {
+        const answers = await inquirer.prompt(questionsRunFunctions[0]);
+        functionId = answers.function;
+    }
+
+    const functions = localConfig.getFunctions();
+    const func = functions.find((f) => f.$id === functionId);
+    if (!func) {
+        throw new Error("Function '" + functionId + "' not found.")
+    }
+
+    const runtimeName = func.runtime.split("-").slice(0, -1).join("-");
+    const tool = systemTools[runtimeName];
+
+    // Configuration: Port
+    if(port) {
+        port = +port;
+    }
+
+    if(isNaN(port)) {
+        port = null;
+    }
+
+    if(port) {
+        const taken = await isPortTaken(port);
+
+        if(taken) {
+            error(`Port ${port} is already in use by another process.`);
+            return;
+        }
+    }
+
+    if(!port) {
+        let portFound = false;
+        port = 3000;
+        while(port < 3100) {
+            const taken = await isPortTaken(port);
+            if(!taken) {
+                portFound = true;
+                break;
+            }
+
+            port++;
+        }
+
+        if(!portFound) {
+            error("Could not find an available port. Please select a port with 'appwrite run --port YOUR_PORT' command.");
+            return;
+        }
+    }
+
+    // Configuration: Engine
+    if(!systemHasCommand('docker')) {
+        return error("Docker Engine is required for local development. Please install Docker using: https://docs.docker.com/engine/install/");
+    }
+
+    // Settings
+    const settings = {
+        runtime: func.runtime,
+        entrypoint: func.entrypoint,
+        path: func.path,
+        commands: func.commands,
+        scopes: func.scopes ?? []
+    };
+
+    drawTable([settings]);
+    log("If you wish to change your local settings, update the appwrite.json file and rerun the 'appwrite run' command.");
+    hint("Permissions, events, CRON and timeouts dont apply when running locally.");
+
+    await dockerCleanup(func.$id);
+
+    process.on('SIGINT', async () => {
+        log('Cleaning up ...');
+        await dockerCleanup(func.$id);
+        success("Local function successfully stopped.");
+        process.exit();
+    });
+
+    const logsPath = path.join(localConfig.getDirname(), func.path, '.appwrite/logs.txt');
+    const errorsPath = path.join(localConfig.getDirname(), func.path, '.appwrite/errors.txt');
+
+    if(!fs.existsSync(path.dirname(logsPath))) {
+        fs.mkdirSync(path.dirname(logsPath), { recursive: true });
+    }
+
+    if (!fs.existsSync(logsPath)) {
+        fs.writeFileSync(logsPath, '');
+    }
+
+    if (!fs.existsSync(errorsPath)) {
+        fs.writeFileSync(errorsPath, '');
+    }
+
+    const userVariables = {};
+    const allVariables = {};
+
+    if(withVariables) {
+        try {
+            const { variables: remoteVariables } = await paginate(functionsListVariables, {
+                functionId: func['$id'],
+                parseOutput: false
+            }, 100, 'variables');
+
+            remoteVariables.forEach((v) => {
+                allVariables[v.key] = v.value;
+                userVariables[v.key] = v.value;
+            });
+        } catch(err) {
+            warn("Remote variables not fetched. Production environment variables will not be available. Reason: " + err.message);
+        }
+    }
+
+    const functionPath = path.join(localConfig.getDirname(), func.path);
+    const envPath = path.join(functionPath, '.env');
+    if(fs.existsSync(envPath)) {
+        const env = parseDotenv(fs.readFileSync(envPath).toString() ?? '');
+
+        Object.keys(env).forEach((key) => {
+            allVariables[key] = env[key];
+            userVariables[key] = env[key];
+        });
+    }
+
+    allVariables['APPWRITE_FUNCTION_API_ENDPOINT'] = globalConfig.getFrom('endpoint');
+    allVariables['APPWRITE_FUNCTION_ID'] = func.$id;
+    allVariables['APPWRITE_FUNCTION_NAME'] = func.name;
+    allVariables['APPWRITE_FUNCTION_DEPLOYMENT'] = ''; // TODO: Implement when relevant
+    allVariables['APPWRITE_FUNCTION_PROJECT_ID'] = localConfig.getProject().projectId;
+    allVariables['APPWRITE_FUNCTION_RUNTIME_NAME'] = runtimeNames[runtimeName] ?? '';
+    allVariables['APPWRITE_FUNCTION_RUNTIME_VERSION'] = func.runtime;
+
+    try {
+        await JwtManager.setup(userId, func.scopes ?? []);
+    } catch(err) {
+        warn("Dynamic API key not generated. Header x-appwrite-key will not be set. Reason: " + err.message);
+    }
+
+    const headers = {};
+    headers['x-appwrite-key'] = JwtManager.functionJwt ?? '';
+    headers['x-appwrite-trigger'] = 'http';
+    headers['x-appwrite-event'] = '';
+    headers['x-appwrite-user-id'] = userId ?? '';
+    headers['x-appwrite-user-jwt'] = JwtManager.userJwt ?? '';
+    allVariables['OPEN_RUNTIMES_HEADERS'] = JSON.stringify(headers);
+
+    if(Object.keys(userVariables).length > 0) {
+        drawTable(Object.keys(userVariables).map((key) => ({
+            key,
+            value: userVariables[key].split("").filter((_, i) => i < 16).map(() => "*").join("")
+        })));
+    }
+
+    await dockerPull(func);
+
+    new Tail(logsPath).on("line", function(data) {
+        process.stdout.write(chalk.white(`${data}\n`));
+    });
+    new Tail(errorsPath).on("line", function(data) {
+        process.stdout.write(chalk.white(`${data}\n`));
+    });
+
+    if(reload) {
+        const ignorer = ignore();
+        ignorer.add('.appwrite');
+        ignorer.add('code.tar.gz');
+
+        if (func.ignore) {
+            ignorer.add(func.ignore);
+        } else if (fs.existsSync(path.join(functionPath, '.gitignore'))) {
+            ignorer.add(fs.readFileSync(path.join(functionPath, '.gitignore')).toString());
+        }
+
+        chokidar.watch('.', {
+            cwd: path.join(localConfig.getDirname(), func.path),
+            ignoreInitial: true,
+            ignored: (xpath) => {
+                const relativePath = path.relative(functionPath, xpath);
+
+                if(!relativePath) {
+                    return false;
+                }
+                return ignorer.ignores(relativePath);
+            }
+        }).on('all', async (_event, filePath) => {
+            Queue.push(filePath);
+        });
+    }
+
+    Queue.events.on('reload', async ({ files }) => {
+        Queue.lock();
+
+        try {
+            await dockerStop(func.$id);
+
+            const dependencyFile = files.find((filePath) => tool.dependencyFiles.includes(filePath));
+            if(tool.isCompiled || dependencyFile) {
+                log(`Rebuilding the function due to file changes ...`);
+                await dockerBuild(func, allVariables);
+
+                if(!Queue.isEmpty()) {
+                    Queue.unlock();
+                    return;
+                }
+
+                await dockerStart(func, allVariables, port);
+            } else {
+                log('Hot-swapping function.. Files with change are ' + files.join(', '));
+
+                const hotSwapPath = path.join(functionPath, '.appwrite/hot-swap');
+                const buildPath = path.join(functionPath, '.appwrite/build.tar.gz');
+
+                // Prepare temp folder
+                if (!fs.existsSync(hotSwapPath)) {
+                    fs.mkdirSync(hotSwapPath, { recursive: true });
+                } else {
+                    fs.rmSync(hotSwapPath, { recursive: true, force: true });
+                    fs.mkdirSync(hotSwapPath, { recursive: true });
+                }
+
+                await tar
+                    .extract({
+                        keep: true,
+                        gzip: true,
+                        sync: true,
+                        cwd: hotSwapPath,
+                        file: buildPath
+                    });
+
+                const ignorer = ignore();
+                ignorer.add('.appwrite');
+                if (func.ignore) {
+                    ignorer.add(func.ignore);
+                } else if (fs.existsSync(path.join(functionPath, '.gitignore'))) {
+                    ignorer.add(fs.readFileSync(path.join(functionPath, '.gitignore')).toString());
+                }
+
+                const filesToCopy = getAllFiles(functionPath).map((file) => path.relative(functionPath, file)).filter((file) => !ignorer.ignores(file));
+                for(const f of filesToCopy) {
+                    const filePath = path.join(hotSwapPath, f);
+                    if (fs.existsSync(filePath)) {
+                        fs.rmSync(filePath, { force: true });
+                    }
+
+                    const fileDir = path.dirname(filePath);
+                    if (!fs.existsSync(fileDir)) {
+                        fs.mkdirSync(fileDir, { recursive: true });
+                    }
+
+                    const sourcePath = path.join(functionPath, f);
+                    fs.copyFileSync(sourcePath, filePath);
+                }
+
+                await tar
+                    .create({
+                        gzip: true,
+                        sync: true,
+                        cwd: hotSwapPath,
+                        file: buildPath
+                    }, ['.']);
+
+                await dockerStart(func, allVariables, port);
+            }
+        } catch(err) {
+            console.error(err);
+        } finally {
+            Queue.unlock();
+        }
+    });
+
+    Queue.lock();
+
+    log('Building function using Docker ...');
+    await dockerBuild(func, allVariables);
+
+    if(!Queue.isEmpty()) {
+        Queue.unlock();
+        return;
+    }
+
+    log('Starting function using Docker ...');
+    hint('Function automatically restarts when you edit your code.');
+    await dockerStart(func, allVariables, port);
+
+    Queue.unlock();
+}
+
+const run = new Command("run")
+    .description(commandDescriptions['run'])
+    .configureHelp({
+        helpWidth: process.stdout.columns || 80
+    })
+    .action(actionRunner(async (_options, command) => {
+        command.help();
+    }));
+
+run
+    .command("function")
+    .alias("functions")
+    .description("Run functions in the current directory.")
+    .option(`--function-id <function-id>`, `ID of function to run`)
+    .option(`--port <port>`, `Local port`)
+    .option(`--user-id <user-id>`, `ID of user to impersonate`)
+    .option(`--with-variables`, `Run with function variables from function settings`)
+    .option(`--no-reload`, `Prevent live reloading of server when changes are made to function files`)
+    .action(actionRunner(runFunction));
+
+module.exports = {
+    run
+}