chirag-appwrite-cli 0.1.0

package/lib/emulation/docker.js

@@ -0,0 +1,264 @@
+const tar = require("tar");
+const ignore = require("ignore");
+const net = require('net');
+const chalk = require('chalk');
+const childProcess = require('child_process');
+const { localConfig } = require("../config");
+const path = require('path');
+const fs = require('fs');
+const { log, error, success, hint } = require("../parser");
+const { openRuntimesVersion, systemTools, Queue } = require("./utils");
+const { getAllFiles } = require("../utils");
+
+async function dockerStop(id) {
+    const stopProcess = childProcess.spawn('docker', ['rm', '--force', id], {
+        stdio: 'pipe',
+        env: {
+            ...process.env,
+            DOCKER_CLI_HINTS: 'false'
+        }
+    });
+
+    await new Promise((res) => { stopProcess.on('close', res) });
+}
+
+async function dockerPull(func) {
+    const runtimeChunks = func.runtime.split("-");
+    const runtimeVersion = runtimeChunks.pop();
+    const runtimeName = runtimeChunks.join("-");
+    const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+    log('Verifying Docker image ...');
+
+    const pullProcess = childProcess.spawn('docker', ['pull', imageName], {
+        stdio: 'pipe',
+        env: {
+            ...process.env,
+            DOCKER_CLI_HINTS: 'false'
+        }
+    });
+
+    await new Promise((res) => { pullProcess.on('close', res) });
+}
+
+async function dockerBuild(func, variables) {
+    const runtimeChunks = func.runtime.split("-");
+    const runtimeVersion = runtimeChunks.pop();
+    const runtimeName = runtimeChunks.join("-");
+    const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+    const functionDir = path.join(localConfig.getDirname(), func.path);
+
+    const id = func.$id;
+
+    const ignorer = ignore();
+    ignorer.add('.appwrite');
+    if (func.ignore) {
+        ignorer.add(func.ignore);
+    } else if (fs.existsSync(path.join(functionDir, '.gitignore'))) {
+        ignorer.add(fs.readFileSync(path.join(functionDir, '.gitignore')).toString());
+    }
+    
+    const files = getAllFiles(functionDir).map((file) => path.relative(functionDir, file)).filter((file) => !ignorer.ignores(file));
+    const tmpBuildPath = path.join(functionDir, '.appwrite/tmp-build');
+    if (!fs.existsSync(tmpBuildPath)) {
+        fs.mkdirSync(tmpBuildPath, { recursive: true });
+    }
+
+    for(const f of files) {
+        const filePath = path.join(tmpBuildPath, f);
+        const fileDir = path.dirname(filePath);
+        if (!fs.existsSync(fileDir)) {
+            fs.mkdirSync(fileDir, { recursive: true });
+        }
+
+        const sourcePath = path.join(functionDir, f);
+        fs.copyFileSync(sourcePath, filePath);
+    }
+
+    const params = [ 'run' ];
+    params.push('--name', id);
+    params.push('-v', `${tmpBuildPath}/:/mnt/code:rw`);
+    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,
+        env: {
+            ...process.env,
+            DOCKER_CLI_HINTS: 'false'
+        }
+    });
+
+    buildProcess.stdout.on('data', (data) => {
+        process.stdout.write(chalk.blackBright(`${data}\n`));
+    });
+
+    buildProcess.stderr.on('data', (data) => {
+        process.stderr.write(chalk.blackBright(`${data}\n`));
+    });
+
+    const killInterval = setInterval(() => {
+        if(!Queue.isEmpty()) {
+            log('Cancelling build ...');
+            buildProcess.stdout.destroy();
+            buildProcess.stdin.destroy();
+            buildProcess.stderr.destroy();
+            buildProcess.kill("SIGKILL");
+            clearInterval(killInterval);
+        }
+    }, 100);
+
+    await new Promise((res) => { buildProcess.on('close', res) });
+
+    clearInterval(killInterval);
+    if(!Queue.isEmpty()) {
+        return;
+    }
+
+    const copyPath = path.join(localConfig.getDirname(), 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,
+        env: {
+            ...process.env,
+            DOCKER_CLI_HINTS: 'false'
+        }
+    });
+
+    await new Promise((res) => { copyProcess.on('close', res) });
+
+    await dockerStop(id);
+
+    const tempPath = path.join(localConfig.getDirname(), func.path, 'code.tar.gz');
+    if (fs.existsSync(tempPath)) {
+        fs.rmSync(tempPath, { force: true });
+    }
+
+    fs.rmSync(tmpBuildPath, { recursive: true, force: true });
+}
+
+async function dockerStart(func, variables, port) {
+    // Pack function files
+    const functionDir = path.join(localConfig.getDirname(), func.path);
+
+    const runtimeChunks = func.runtime.split("-");
+    const runtimeVersion = runtimeChunks.pop();
+    const runtimeName = runtimeChunks.join("-");
+    const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+    const tool = systemTools[runtimeName];
+
+    const id = func.$id;
+
+    const params = [ 'run' ];
+    params.push('--rm');
+    params.push('--name', id);
+    params.push('-p', `${port}:3000`);
+    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}"`);
+
+    const startProcess = childProcess.spawn('docker', params, {
+        stdio: 'pipe',
+        pwd: functionDir,
+        env: {
+            ...process.env,
+            DOCKER_CLI_HINTS: 'false'
+        }
+    });
+
+    startProcess.stdout.on('data', (data) => {
+        process.stdout.write(chalk.blackBright(data));
+    });
+
+    startProcess.stderr.on('data', (data) => {
+        process.stdout.write(chalk.blackBright(data));
+    });
+
+    try {
+        await waitUntilPortOpen(port);
+    } catch(err) {
+        error("Failed to start function with error: " + err.message ? err.message : err.toString());
+        return;
+    }
+
+    success(`Visit http://localhost:${port}/ to execute your function.`);
+}
+
+async function dockerCleanup(functionId) {
+    await dockerStop(functionId);
+
+    const func = localConfig.getFunction(functionId);
+    const appwritePath = path.join(localConfig.getDirname(), func.path, '.appwrite');
+    if (fs.existsSync(appwritePath)) {
+        fs.rmSync(appwritePath, { recursive: true, force: true });
+    }
+
+    const tempPath = path.join(localConfig.getDirname(), func.path, 'code.tar.gz');
+    if (fs.existsSync(tempPath)) {
+        fs.rmSync(tempPath, { force: true });
+    }
+}
+
+function waitUntilPortOpen(port, iteration = 0) {
+    return new Promise((resolve, reject) => {
+        const client = new net.Socket();
+
+        client.once('connect', () => {
+            client.removeAllListeners('connect');
+            client.removeAllListeners('error');
+            client.end();
+            client.destroy();
+            client.unref();
+
+            resolve();
+        });
+
+        client.once('error', async (err) => {
+            client.removeAllListeners('connect');
+            client.removeAllListeners('error');
+            client.end();
+            client.destroy();
+            client.unref();
+
+            if(iteration > 100) {
+                reject(err);
+            } else {
+                await new Promise((res) => setTimeout(res, 100));
+                waitUntilPortOpen(port, iteration + 1).then(resolve).catch(reject);
+            }
+        });
+
+        client.connect({port, host: '127.0.0.1'}, function() {});
+    });
+}
+
+module.exports = {
+    dockerPull,
+    dockerBuild,
+    dockerStart,
+    dockerCleanup,
+    dockerStop,
+}

package/lib/emulation/utils.js

@@ -0,0 +1,186 @@
+const EventEmitter = require('node:events');
+const { projectsCreateJWT } = require('../commands/projects');
+const { localConfig } = require("../config");
+const { usersGet, usersCreateJWT } = require("../commands/users");
+const { log } = require("../parser");
+
+const openRuntimesVersion = 'v4';
+
+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',
+    'go': 'Go',
+};
+
+const systemTools = {
+    'node': {
+        isCompiled: false,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ "package.json", "package-lock.json" ]
+    },
+    'php': {
+        isCompiled: false,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ "composer.json", "composer.lock" ]
+    },
+    'ruby': {
+        isCompiled: false,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ "Gemfile", "Gemfile.lock" ]
+    },
+    'python': {
+        isCompiled: false,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ "requirements.txt", "requirements.lock" ]
+    },
+    'python-ml': {
+        isCompiled: false,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ "requirements.txt", "requirements.lock" ]
+    },
+    'deno': {
+        isCompiled: false,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ ]
+    },
+    'dart': {
+        isCompiled: true,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ ]
+    },
+    'dotnet': {
+        isCompiled: true,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ ]
+    },
+    'java': {
+        isCompiled: true,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ ]
+    },
+    'swift': {
+        isCompiled: true,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ ]
+    },
+    'kotlin': {
+        isCompiled: true,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ ]
+    },
+    'bun': {
+        isCompiled: false,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ "package.json", "package-lock.json", "bun.lockb" ]
+    },
+    'go': {
+        isCompiled: true,
+        startCommand: "sh helpers/server.sh",
+        dependencyFiles: [ ]
+    },
+};
+
+const JwtManager = {
+    userJwt: null,
+    functionJwt: null,
+
+    timerWarn: null,
+    timerError: null,
+
+    async setup(userId = null, projectScopes = []) {
+        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,
+            scopes: projectScopes,
+            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;
+    },
+    isEmpty() {
+        return this.files.length === 0
+    },
+    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/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/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

@@ -0,0 +1,52 @@
+const paginate = async (action, args = {}, limit = 100, wrapper = '', queries = []) => {
+    let pageNumber = 0;
+    let results = [];
+    let total = 0;
+
+    while (true) {
+        const offset = pageNumber * limit;
+
+        // Merge the limit and offset into the args
+        const response = await action({
+            ...args,
+            queries: [
+                ...queries,
+                JSON.stringify({ method: 'limit', values: [limit] }),
+                JSON.stringify({ method: 'offset', values: [offset] })
+            ]
+        });
+
+        if (wrapper === '') {
+            if (response.length === 0) {
+                break;
+            }
+            results = results.concat(response);
+        } else {
+            if (response[wrapper].length === 0) {
+                break;
+            }
+            results = results.concat(response[wrapper]);
+        }
+
+        total = response.total;
+
+        if (results.length >= total) {
+            break;
+        }
+
+        pageNumber++;
+    }
+
+    if (wrapper === '') {
+        return results;
+    }
+
+    return {
+        [wrapper]: results,
+        total,
+    };
+}
+
+module.exports = {
+    paginate
+};