appwrite-cli 12.0.1 → 13.0.0-rc.1

package/index.ts

@@ -0,0 +1,152 @@
+#! /usr/bin/env node
+
+/** Required to set max width of the help commands */
+const oldWidth = process.stdout.columns;
+process.stdout.columns = 100;
+/** ---------------------------------------------- */
+
+import program = require('commander');
+import chalk = require('chalk');
+const { version } = require('../package.json');
+import { commandDescriptions, cliConfig } from './lib/parser';
+import { client } from './lib/commands/generic';
+import { getLatestVersion, compareVersions } from './lib/utils';
+import inquirer = require('inquirer');
+import { login, logout, whoami, migrate, register } from './lib/commands/generic';
+import { init } from './lib/commands/init';
+import { types } from './lib/commands/types';
+import { pull } from './lib/commands/pull';
+import { run } from './lib/commands/run';
+import { push, deploy } from './lib/commands/push';
+import { update } from './lib/commands/update';
+import { account } from './lib/commands/account';
+import { console } from './lib/commands/console';
+import { databases } from './lib/commands/databases';
+import { functions } from './lib/commands/functions';
+import { graphql } from './lib/commands/graphql';
+import { health } from './lib/commands/health';
+import { locale } from './lib/commands/locale';
+import { messaging } from './lib/commands/messaging';
+import { migrations } from './lib/commands/migrations';
+import { project } from './lib/commands/project';
+import { projects } from './lib/commands/projects';
+import { proxy } from './lib/commands/proxy';
+import { sites } from './lib/commands/sites';
+import { storage } from './lib/commands/storage';
+import { tablesDB } from './lib/commands/tables-db';
+import { teams } from './lib/commands/teams';
+import { tokens } from './lib/commands/tokens';
+import { users } from './lib/commands/users';
+import { vcs } from './lib/commands/vcs';
+
+inquirer.registerPrompt('search-list', require('inquirer-search-list'));
+
+/**
+ * Check for updates and show version information
+ */
+async function checkVersion(): Promise<void> {
+    process.stdout.write(chalk.bold(`appwrite version ${version}`) + '\n');
+
+    try {
+        const latestVersion = await getLatestVersion();
+        const comparison = compareVersions(version, latestVersion);
+
+        if (comparison > 0) {
+            // Current version is older than latest
+            process.stdout.write(
+                chalk.yellow(`\n⚠️  A newer version is available: ${chalk.bold(latestVersion)}`) + '\n'
+            );
+            process.stdout.write(
+                chalk.cyan(
+                    `💡 Run '${chalk.bold('appwrite update')}' to update to the latest version.`
+                ) + '\n'
+            );
+        } else if (comparison === 0) {
+            process.stdout.write(chalk.green('\n✅ You are running the latest version!') + '\n');
+        } else {
+            // Current version is newer than latest (pre-release/dev)
+            process.stdout.write(chalk.blue('\n🚀 You are running a pre-release or development version.') + '\n');
+        }
+    } catch (error) {
+        // Silently fail version check, just show current version
+        process.stdout.write(chalk.gray('\n(Unable to check for updates)') + '\n');
+    }
+}
+
+// Intercept version flag before Commander.js processes it
+if (process.argv.includes('-v') || process.argv.includes('--version')) {
+    (async () => {
+        await checkVersion();
+        process.exit(0);
+    })();
+} else {
+    program
+        .description(commandDescriptions['main'])
+        .configureHelp({
+            helpWidth: process.stdout.columns || 80,
+            sortSubcommands: true,
+        })
+        .helpOption('-h, --help', 'Display help for command')
+        .version(version, '-v, --version', 'Output the version number')
+        .option('-V, --verbose', 'Show complete error log')
+        .option('-j, --json', 'Output in JSON format')
+        .hook('preAction', migrate)
+        .option('-f,--force', 'Flag to confirm all warnings')
+        .option('-a,--all', 'Flag to push all resources')
+        .option('--id [id...]', 'Flag to pass a list of ids for a given action')
+        .option('--report', 'Enable reporting in case of CLI errors')
+        .on('option:json', () => {
+            cliConfig.json = true;
+        })
+        .on('option:verbose', () => {
+            cliConfig.verbose = true;
+        })
+        .on('option:report', function () {
+            cliConfig.report = true;
+            cliConfig.reportData = { data: this };
+        })
+        .on('option:force', () => {
+            cliConfig.force = true;
+        })
+        .on('option:all', () => {
+            cliConfig.all = true;
+        })
+        .on('option:id', function () {
+            cliConfig.ids = (this as any).opts().id;
+        })
+        .showSuggestionAfterError()
+        .addCommand(whoami)
+        .addCommand(register)
+        .addCommand(login)
+        .addCommand(init)
+        .addCommand(pull)
+        .addCommand(push)
+        .addCommand(types)
+        .addCommand(deploy)
+        .addCommand(run)
+        .addCommand(update)
+        .addCommand(logout)
+        .addCommand(account)
+        .addCommand(console)
+        .addCommand(databases)
+        .addCommand(functions)
+        .addCommand(graphql)
+        .addCommand(health)
+        .addCommand(locale)
+        .addCommand(messaging)
+        .addCommand(migrations)
+        .addCommand(project)
+        .addCommand(projects)
+        .addCommand(proxy)
+        .addCommand(sites)
+        .addCommand(storage)
+        .addCommand(tablesDB)
+        .addCommand(teams)
+        .addCommand(tokens)
+        .addCommand(users)
+        .addCommand(vcs)
+        .addCommand(client)
+        .parse(process.argv);
+
+    process.stdout.columns = oldWidth;
+}

package/install.ps1

@@ -13,8 +13,8 @@
 # You can use "View source" of this page to see the full script.
 
 # REPO
-$GITHUB_x64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/12.0.1/appwrite-cli-win-x64.exe"
-$GITHUB_arm64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/12.0.1/appwrite-cli-win-arm64.exe"
+$GITHUB_x64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/13.0.0-rc.1/appwrite-cli-win-x64.exe"
+$GITHUB_arm64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/13.0.0-rc.1/appwrite-cli-win-arm64.exe"
 
 $APPWRITE_BINARY_NAME = "appwrite.exe"
 
@@ -41,7 +41,6 @@ function Greeting {
     Write-Host "Welcome to the Appwrite CLI install shield."  
 }
 
-
 function CheckSystemInfo {
     Write-Host "[1/4] Getting System Info ..."
     if ((Get-ExecutionPolicy) -gt 'RemoteSigned' -or (Get-ExecutionPolicy) -eq 'ByPass') {
@@ -66,7 +65,6 @@ function DownloadBinary {
     Move-Item $APPWRITE_DOWNLOAD_DIR $APPWRITE_INSTALL_PATH
 }
 
-
 function Install {
     Write-Host "[3/4] Starting installation ..."
 
@@ -89,7 +87,6 @@ function InstallCompleted {
     Write-Host "As first step, you can login to your Appwrite account using 'appwrite login'"
 }
 
-
 Greeting
 CheckSystemInfo
 DownloadBinary

package/install.sh

@@ -39,7 +39,6 @@ RED='\033[0;31m'
 GREEN='\033[0;32m'
 NC='\033[0m' # No Color
 
-
 greeting() {
     echo -e "${RED}"
     cat << "EOF"
@@ -97,7 +96,7 @@ printSuccess() {
 downloadBinary() {
     echo "[2/4] Downloading executable for $OS ($ARCH) ..."
 
-    GITHUB_LATEST_VERSION="12.0.1"
+    GITHUB_LATEST_VERSION="13.0.0-rc.1"
     GITHUB_FILE="appwrite-cli-${OS}-${ARCH}"
     GITHUB_URL="https://github.com/$GITHUB_REPOSITORY_NAME/releases/download/$GITHUB_LATEST_VERSION/$GITHUB_FILE"
 

package/lib/client.ts

@@ -0,0 +1,259 @@
+import os = require('os');
+import { fetch, FormData, Agent } from 'undici';
+import JSONbig = require('json-bigint');
+import AppwriteException = require('./exception');
+import { globalConfig } from './config';
+import chalk = require('chalk');
+import type { Headers, RequestParams, ResponseType, FileUpload } from './types';
+
+const JSONBigInt = JSONbig({ storeAsString: false });
+
+class Client {
+    private readonly CHUNK_SIZE = 5 * 1024 * 1024; // 5MB
+    private endpoint: string;
+    private headers: Headers;
+    private selfSigned: boolean;
+
+    constructor() {
+        this.endpoint = 'https://cloud.appwrite.io/v1';
+        this.selfSigned = false;
+        this.headers = {
+            'content-type': '',
+            'x-sdk-name': 'Command Line',
+            'x-sdk-platform': 'console',
+            'x-sdk-language': 'cli',
+            'x-sdk-version': '13.0.0-rc.1',
+            'user-agent': `AppwriteCLI/13.0.0-rc.1 (${os.type()} ${os.version()}; ${os.arch()})`,
+            'X-Appwrite-Response-Format': '1.8.0',
+        };
+    }
+
+    /**
+     * Set Cookie
+     *
+     * Your cookie
+     *
+     * @param {string} cookie
+     *
+     * @return self
+     */
+    setCookie(cookie: string): this {
+        this.addHeader('cookie', cookie);
+        return this;
+    }
+
+    /**
+     * Set Project
+     *
+     * Your project ID
+     *
+     * @param {string} project
+     *
+     * @return self
+     */
+    setProject(project: string): this {
+        this.addHeader('X-Appwrite-Project', project);
+        return this;
+    }
+
+    /**
+     * Set Key
+     *
+     * Your secret API key
+     *
+     * @param {string} key
+     *
+     * @return self
+     */
+    setKey(key: string): this {
+        this.addHeader('X-Appwrite-Key', key);
+        return this;
+    }
+
+    /**
+     * Set JWT
+     *
+     * Your secret JSON Web Token
+     *
+     * @param {string} jwt
+     *
+     * @return self
+     */
+    setJWT(jwt: string): this {
+        this.addHeader('X-Appwrite-JWT', jwt);
+        return this;
+    }
+
+    /**
+     * Set Locale
+     *
+     * @param {string} locale
+     *
+     * @return self
+     */
+    setLocale(locale: string): this {
+        this.addHeader('X-Appwrite-Locale', locale);
+        return this;
+    }
+
+    /**
+     * Set Mode
+     *
+     * @param {string} mode
+     *
+     * @return self
+     */
+    setMode(mode: string): this {
+        this.addHeader('X-Appwrite-Mode', mode);
+        return this;
+    }
+
+    /**
+     * Set self signed.
+     *
+     * @param {bool} status
+     *
+     * @return this
+     */
+    setSelfSigned(status: boolean): this {
+        this.selfSigned = status;
+        return this;
+    }
+
+    /**
+     * Set endpoint.
+     *
+     * @param {string} endpoint
+     *
+     * @return this
+     */
+    setEndpoint(endpoint: string): this {
+        if (!endpoint.startsWith('http://') && !endpoint.startsWith('https://')) {
+            throw new AppwriteException('Invalid endpoint URL: ' + endpoint);
+        }
+
+        this.endpoint = endpoint;
+        return this;
+    }
+
+    /**
+     * @param {string} key
+     * @param {string} value
+     */
+    addHeader(key: string, value: string): this {
+        this.headers[key.toLowerCase()] = value;
+        return this;
+    }
+
+    async call<T = unknown>(
+        method: string,
+        path: string = '',
+        headers: Headers = {},
+        params: RequestParams = {},
+        responseType: ResponseType = 'json'
+    ): Promise<T> {
+        const mergedHeaders: Headers = { ...this.headers, ...headers };
+        const url = new URL(this.endpoint + path);
+
+        let body: FormData | string | undefined = undefined;
+
+        if (method.toUpperCase() === 'GET') {
+            url.search = new URLSearchParams(Client.flatten(params) as Record<string, string>).toString();
+        } else if (mergedHeaders['content-type']?.toLowerCase().startsWith('multipart/form-data')) {
+            delete mergedHeaders['content-type'];
+            const formData = new FormData();
+
+            const flatParams = Client.flatten(params);
+
+            for (const [key, value] of Object.entries(flatParams)) {
+                if (value && typeof value === 'object' && 'type' in value && value.type === 'file') {
+                    const fileUpload = value as FileUpload;
+                    formData.append(key, fileUpload.file as any, fileUpload.filename);
+                } else {
+                    formData.append(key, value as string);
+                }
+            }
+
+            body = formData;
+        } else {
+            body = JSONBigInt.stringify(params);
+        }
+
+        let response: Awaited<ReturnType<typeof fetch>> | undefined = undefined;
+        try {
+            response = await fetch(url.toString(), {
+                method: method.toUpperCase(),
+                headers: mergedHeaders,
+                body,
+                dispatcher: new Agent({
+                    connect: {
+                        rejectUnauthorized: !this.selfSigned,
+                    },
+                }),
+            });
+        } catch (error) {
+            throw new AppwriteException((error as Error).message);
+        }
+
+        if (response.status >= 400) {
+            const text = await response.text();
+            let json: { message?: string; code?: number; type?: string } | undefined = undefined;
+            try {
+                json = JSON.parse(text);
+            } catch (error) {
+                throw new AppwriteException(text, response.status, '', text);
+            }
+
+            if (path !== '/account' && json.code === 401 && json.type === 'user_more_factors_required') {
+                console.log(`${chalk.cyan.bold('ℹ Info')} ${chalk.cyan('Unusable account found, removing...')}`);
+
+                const current = globalConfig.getCurrentSession();
+                globalConfig.setCurrentSession('');
+                globalConfig.removeSession(current);
+            }
+            throw new AppwriteException(json.message || text, json.code, json.type, text);
+        }
+
+        if (responseType === 'arraybuffer') {
+            const data = await response.arrayBuffer();
+            return data as T;
+        }
+
+        const cookies = response.headers.getSetCookie();
+        if (cookies && cookies.length > 0) {
+            for (const cookie of cookies) {
+                if (cookie.startsWith('a_session_console=')) {
+                    globalConfig.setCookie(cookie);
+                }
+            }
+        }
+
+        const text = await response.text();
+        let json: T | undefined = undefined;
+        try {
+            json = JSONBigInt.parse(text);
+        } catch (error) {
+            return text as T;
+        }
+        return json as T;
+    }
+
+    static flatten(data: RequestParams, prefix: string = ''): Record<string, unknown> {
+        let output: Record<string, unknown> = {};
+
+        for (const key in data) {
+            const value = data[key];
+            const finalKey = prefix ? prefix + '[' + key + ']' : key;
+
+            if (Array.isArray(value)) {
+                output = { ...output, ...Client.flatten(value as unknown as RequestParams, finalKey) };
+            } else {
+                output[finalKey] = value;
+            }
+        }
+
+        return output;
+    }
+}
+
+export = Client;