appwrite-cli 12.0.1 → 13.0.0-rc.1

package/lib/emulation/{docker.js → docker.ts}

@@ -1,16 +1,24 @@
-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) {
+import ignore = require('ignore');
+import net = require('net');
+import chalk from 'chalk';
+import childProcess = require('child_process');
+import { localConfig } from '../config';
+import path = require('path');
+import fs = require('fs');
+import { log, error, success } from '../parser';
+import { openRuntimesVersion, systemTools, Queue } from './utils';
+import { getAllFiles } from '../utils';
+
+interface FunctionConfig {
+    $id: string;
+    runtime: string;
+    path: string;
+    entrypoint: string;
+    commands: string;
+    ignore?: string;
+}
+
+export async function dockerStop(id: string): Promise<void> {
     const stopProcess = childProcess.spawn('docker', ['rm', '--force', id], {
         stdio: 'pipe',
         env: {
@@ -19,10 +27,10 @@ async function dockerStop(id) {
         }
     });
 
-    await new Promise((res) => { stopProcess.on('close', res) });
+    await new Promise<void>((res) => { stopProcess.on('close', res) });
 }
 
-async function dockerPull(func) {
+export async function dockerPull(func: FunctionConfig): Promise<void> {
     const runtimeChunks = func.runtime.split("-");
     const runtimeVersion = runtimeChunks.pop();
     const runtimeName = runtimeChunks.join("-");
@@ -38,10 +46,10 @@ async function dockerPull(func) {
         }
     });
 
-    await new Promise((res) => { pullProcess.on('close', res) });
+    await new Promise<void>((res) => { pullProcess.on('close', res) });
 }
 
-async function dockerBuild(func, variables) {
+export async function dockerBuild(func: FunctionConfig, variables: Record<string, string>): Promise<void> {
     const runtimeChunks = func.runtime.split("-");
     const runtimeVersion = runtimeChunks.pop();
     const runtimeName = runtimeChunks.join("-");
@@ -51,7 +59,7 @@ async function dockerBuild(func, variables) {
 
     const id = func.$id;
 
-    const ignorer = ignore();
+    const ignorer = ignore.default();
     ignorer.add('.appwrite');
     if (func.ignore) {
         ignorer.add(func.ignore);
@@ -76,7 +84,7 @@ async function dockerBuild(func, variables) {
         fs.copyFileSync(sourcePath, filePath);
     }
 
-    const params = [ 'run' ];
+    const params: string[] = [ 'run' ];
     params.push('--name', id);
     params.push('-v', `${tmpBuildPath}/:/mnt/code:rw`);
     params.push('-e', 'OPEN_RUNTIMES_ENV=development');
@@ -91,7 +99,7 @@ async function dockerBuild(func, variables) {
 
     const buildProcess = childProcess.spawn('docker', params, {
         stdio: 'pipe',
-        pwd: functionDir,
+        cwd: functionDir,
         env: {
             ...process.env,
             DOCKER_CLI_HINTS: 'false'
@@ -117,7 +125,7 @@ async function dockerBuild(func, variables) {
         }
     }, 100);
 
-    await new Promise((res) => { buildProcess.on('close', res) });
+    await new Promise<void>((res) => { buildProcess.on('close', res) });
 
     clearInterval(killInterval);
     if(!Queue.isEmpty()) {
@@ -132,14 +140,14 @@ async function dockerBuild(func, variables) {
 
     const copyProcess = childProcess.spawn('docker', ['cp', `${id}:/mnt/code/code.tar.gz`, copyPath], {
         stdio: 'pipe',
-        pwd: functionDir,
+        cwd: functionDir,
         env: {
             ...process.env,
             DOCKER_CLI_HINTS: 'false'
         }
     });
 
-    await new Promise((res) => { copyProcess.on('close', res) });
+    await new Promise<void>((res) => { copyProcess.on('close', res) });
 
     await dockerStop(id);
 
@@ -151,7 +159,7 @@ async function dockerBuild(func, variables) {
     fs.rmSync(tmpBuildPath, { recursive: true, force: true });
 }
 
-async function dockerStart(func, variables, port) {
+export async function dockerStart(func: FunctionConfig, variables: Record<string, string>, port: number): Promise<void> {
     // Pack function files
     const functionDir = path.join(localConfig.getDirname(), func.path);
 
@@ -164,7 +172,7 @@ async function dockerStart(func, variables, port) {
 
     const id = func.$id;
 
-    const params = [ 'run' ];
+    const params: string[] = [ 'run' ];
     params.push('--rm');
     params.push('--name', id);
     params.push('-p', `${port}:3000`);
@@ -182,7 +190,7 @@ async function dockerStart(func, variables, port) {
 
     const startProcess = childProcess.spawn('docker', params, {
         stdio: 'pipe',
-        pwd: functionDir,
+        cwd: functionDir,
         env: {
             ...process.env,
             DOCKER_CLI_HINTS: 'false'
@@ -199,15 +207,15 @@ async function dockerStart(func, variables, port) {
 
     try {
         await waitUntilPortOpen(port);
-    } catch(err) {
-        error("Failed to start function with error: " + err.message ? err.message : err.toString());
+    } catch(err: any) {
+        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) {
+export async function dockerCleanup(functionId: string): Promise<void> {
     await dockerStop(functionId);
 
     const func = localConfig.getFunction(functionId);
@@ -222,7 +230,7 @@ async function dockerCleanup(functionId) {
     }
 }
 
-function waitUntilPortOpen(port, iteration = 0) {
+function waitUntilPortOpen(port: number, iteration: number = 0): Promise<void> {
     return new Promise((resolve, reject) => {
         const client = new net.Socket();
 
@@ -246,7 +254,7 @@ function waitUntilPortOpen(port, iteration = 0) {
             if(iteration > 100) {
                 reject(err);
             } else {
-                await new Promise((res) => setTimeout(res, 100));
+                await new Promise<void>((res) => setTimeout(res, 100));
                 waitUntilPortOpen(port, iteration + 1).then(resolve).catch(reject);
             }
         });
@@ -255,10 +263,3 @@ function waitUntilPortOpen(port, iteration = 0) {
     });
 }
 
-module.exports = {
-    dockerPull,
-    dockerBuild,
-    dockerStart,
-    dockerCleanup,
-    dockerStop,
-}

package/lib/emulation/utils.ts

@@ -0,0 +1,193 @@
+import { EventEmitter } from 'node:events';
+import { projectsCreateJWT } from '../commands/projects';
+import { localConfig } from '../config';
+import { usersGet, usersCreateJWT } from '../commands/users';
+import { log } from '../parser';
+
+export const openRuntimesVersion = 'v4';
+
+export const runtimeNames: Record<string, string> = {
+    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',
+};
+
+interface SystemTool {
+    isCompiled: boolean;
+    startCommand: string;
+    dependencyFiles: string[];
+}
+
+export const systemTools: Record<string, SystemTool> = {
+    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: [],
+    },
+};
+
+export const JwtManager = {
+    userJwt: null as string | null,
+    functionJwt: null as string | null,
+
+    timerWarn: null as NodeJS.Timeout | null,
+    timerError: null as NodeJS.Timeout | null,
+
+    async setup(userId: string | null = null, projectScopes: string[] = []): Promise<void> {
+        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: any = await usersCreateJWT({
+                userId,
+                duration: 60 * 60,
+                parseOutput: false,
+            });
+            this.userJwt = userResponse.jwt;
+        }
+
+        const functionResponse: any = await projectsCreateJWT({
+            projectId: localConfig.getProject().projectId!,
+            scopes: projectScopes,
+            duration: 60 * 60,
+            parseOutput: false,
+        });
+        this.functionJwt = functionResponse.jwt;
+    },
+};
+
+interface QueueReloadEvent {
+    files: string[];
+}
+
+export const Queue = {
+    files: [] as string[],
+    locked: false,
+    events: new EventEmitter(),
+    debounce: null as NodeJS.Timeout | null,
+
+    push(file: string): void {
+        if (!this.files.includes(file)) {
+            this.files.push(file);
+        }
+
+        if (!this.locked) {
+            this._trigger();
+        }
+    },
+
+    lock(): void {
+        this.files = [];
+        this.locked = true;
+    },
+
+    isEmpty(): boolean {
+        return this.files.length === 0;
+    },
+
+    unlock(): void {
+        this.locked = false;
+        if (this.files.length > 0) {
+            this._trigger();
+        }
+    },
+
+    _trigger(): void {
+        if (this.debounce) {
+            return;
+        }
+
+        this.debounce = setTimeout(() => {
+            this.events.emit('reload', { files: this.files } as QueueReloadEvent);
+            this.debounce = null;
+        }, 300);
+    },
+};

package/lib/exception.ts

@@ -0,0 +1,20 @@
+class AppwriteException extends Error {
+    public code?: number;
+    public type?: string;
+    public response?: string;
+
+    constructor(message: string, code?: number, type?: string, response?: string) {
+        super(message);
+        this.name = 'AppwriteException';
+        this.code = code;
+        this.type = type;
+        this.response = response;
+
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, AppwriteException);
+        }
+    }
+}
+
+export = AppwriteException;

package/lib/{id.js → id.ts}

@@ -1,7 +1,7 @@
 class ID {
     // Generate an hex ID based on timestamp
     // Recreated from https://www.php.net/manual/en/function.uniqid.php
-    static #hexTimestamp() {
+    static #hexTimestamp(): string {
         const now = new Date();
         const sec = Math.floor(now.getTime() / 1000);
         const msec = now.getMilliseconds();
@@ -11,11 +11,11 @@ class ID {
         return hexTimestamp;
     }
 
-    static custom(id) {
-        return id
+    static custom(id: string): string {
+        return id;
     }
 
-    static unique(padding = 7) {
+    static unique(padding: number = 7): string {
         // Generate a unique ID with padding to have a longer ID
         const baseId = ID.#hexTimestamp();
         let randomPadding = '';
@@ -27,4 +27,4 @@ class ID {
     }
 }
 
-module.exports = ID;
+export = ID;

package/lib/paginate.ts

@@ -0,0 +1,63 @@
+interface PaginateArgs {
+    [key: string]: any;
+}
+
+interface PaginateResponse<T = any> {
+    [key: string]: T;
+    total: number;
+}
+
+export const paginate = async <T = any>(
+    action: (args: PaginateArgs) => Promise<any>,
+    args: PaginateArgs = {},
+    limit: number = 100,
+    wrapper: string = '',
+    queries: string[] = []
+): Promise<T[] | PaginateResponse<T[]>> => {
+    let pageNumber = 0;
+    let results: T[] = [];
+    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,
+    } as PaginateResponse<T[]>;
+};