appwrite-cli 12.0.1 → 13.0.0-rc.1

package/lib/commands/{run.js → run.ts}

@@ -1,23 +1,31 @@
-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 } = {}) => {
+import { Tail } from 'tail';
+import { parse as parseDotenv } from 'dotenv';
+import chalk from 'chalk';
+import ignore = require('ignore');
+import tar = require('tar');
+import fs = require('fs');
+import chokidar from 'chokidar';
+import inquirer from 'inquirer';
+import path = require('path');
+import { Command } from 'commander';
+import { localConfig, globalConfig } from '../config';
+import { paginate } from '../paginate';
+import { functionsListVariables } from './functions';
+import { questionsRunFunctions } from '../questions';
+import { actionRunner, success, log, warn, error, hint, commandDescriptions, drawTable } from '../parser';
+import { systemHasCommand, isPortTaken, getAllFiles } from '../utils';
+import { runtimeNames, systemTools, JwtManager, Queue } from '../emulation/utils';
+import { dockerStop, dockerCleanup, dockerStart, dockerBuild, dockerPull } from '../emulation/docker';
+
+interface RunFunctionOptions {
+    port?: string | number;
+    functionId?: string;
+    withVariables?: boolean;
+    reload?: boolean;
+    userId?: string;
+}
+
+const runFunction = async ({ port, functionId, withVariables, reload, userId }: RunFunctionOptions = {}): Promise<void> => {
     // Selection
     if(!functionId) {
         const answers = await inquirer.prompt(questionsRunFunctions[0]);
@@ -25,7 +33,7 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
     }
 
     const functions = localConfig.getFunctions();
-    const func = functions.find((f) => f.$id === functionId);
+    const func = functions.find((f: any) => f.$id === functionId);
     if (!func) {
         throw new Error("Function '" + functionId + "' not found.")
     }
@@ -34,34 +42,35 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
     const tool = systemTools[runtimeName];
 
     // Configuration: Port
+    let portNum: number | null = null;
     if(port) {
-        port = +port;
+        portNum = +port;
     }
 
-    if(isNaN(port)) {
-        port = null;
+    if(isNaN(portNum!)) {
+        portNum = null;
     }
 
-    if(port) {
-        const taken = await isPortTaken(port);
+    if(portNum) {
+        const taken = await isPortTaken(portNum);
 
         if(taken) {
-            error(`Port ${port} is already in use by another process.`);
+            error(`Port ${portNum} is already in use by another process.`);
             return;
         }
     }
 
-    if(!port) {
+    if(!portNum) {
         let portFound = false;
-        port = 3000;
-        while(port < 3100) {
-            const taken = await isPortTaken(port);
+        portNum = 3000;
+        while(portNum < 3100) {
+            const taken = await isPortTaken(portNum);
             if(!taken) {
                 portFound = true;
                 break;
             }
 
-            port++;
+            portNum++;
         }
 
         if(!portFound) {
@@ -112,8 +121,8 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
         fs.writeFileSync(errorsPath, '');
     }
 
-    const userVariables = {};
-    const allVariables = {};
+    const userVariables: Record<string, string> = {};
+    const allVariables: Record<string, string> = {};
 
     if(withVariables) {
         try {
@@ -122,11 +131,11 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
                 parseOutput: false
             }, 100, 'variables');
 
-            remoteVariables.forEach((v) => {
+            remoteVariables.forEach((v: any) => {
                 allVariables[v.key] = v.value;
                 userVariables[v.key] = v.value;
             });
-        } catch(err) {
+        } catch(err: any) {
             warn("Remote variables not fetched. Production environment variables will not be available. Reason: " + err.message);
         }
     }
@@ -152,11 +161,11 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
 
     try {
         await JwtManager.setup(userId, func.scopes ?? []);
-    } catch(err) {
+    } catch(err: any) {
         warn("Dynamic API key not generated. Header x-appwrite-key will not be set. Reason: " + err.message);
     }
 
-    const headers = {};
+    const headers: Record<string, string> = {};
     headers['x-appwrite-key'] = JwtManager.functionJwt ?? '';
     headers['x-appwrite-trigger'] = 'http';
     headers['x-appwrite-event'] = '';
@@ -167,16 +176,16 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
     if(Object.keys(userVariables).length > 0) {
         drawTable(Object.keys(userVariables).map((key) => ({
             key,
-            value: userVariables[key].split("").filter((_, i) => i < 16).map(() => "*").join("")
+            value: userVariables[key].split("").filter((_: string, i: number) => i < 16).map(() => "*").join("")
         })));
     }
 
     await dockerPull(func);
 
-    new Tail(logsPath).on("line", function(data) {
+    new Tail(logsPath).on("line", function(data: string) {
         process.stdout.write(chalk.white(`${data}\n`));
     });
-    new Tail(errorsPath).on("line", function(data) {
+    new Tail(errorsPath).on("line", function(data: string) {
         process.stdout.write(chalk.white(`${data}\n`));
     });
 
@@ -194,7 +203,7 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
         chokidar.watch('.', {
             cwd: path.join(localConfig.getDirname(), func.path),
             ignoreInitial: true,
-            ignored: (xpath) => {
+            ignored: (xpath: string) => {
                 const relativePath = path.relative(functionPath, xpath);
 
                 if(!relativePath) {
@@ -202,18 +211,18 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
                 }
                 return ignorer.ignores(relativePath);
             }
-        }).on('all', async (_event, filePath) => {
+        }).on('all', async (_event: string, filePath: string) => {
             Queue.push(filePath);
         });
     }
 
-    Queue.events.on('reload', async ({ files }) => {
+    Queue.events.on('reload', async ({ files }: { files: string[] }) => {
         Queue.lock();
 
         try {
             await dockerStop(func.$id);
 
-            const dependencyFile = files.find((filePath) => tool.dependencyFiles.includes(filePath));
+            const dependencyFile = files.find((filePath: string) => tool.dependencyFiles.includes(filePath));
             if(tool.isCompiled || dependencyFile) {
                 log(`Rebuilding the function due to file changes ...`);
                 await dockerBuild(func, allVariables);
@@ -223,7 +232,7 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
                     return;
                 }
 
-                await dockerStart(func, allVariables, port);
+                await dockerStart(func, allVariables, portNum!);
             } else {
                 log('Hot-swapping function.. Files with change are ' + files.join(', '));
 
@@ -247,7 +256,7 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
                         file: buildPath
                     });
 
-                const ignorer = ignore();
+                const ignorer = ignore.default();
                 ignorer.add('.appwrite');
                 if (func.ignore) {
                     ignorer.add(func.ignore);
@@ -255,7 +264,7 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
                     ignorer.add(fs.readFileSync(path.join(functionPath, '.gitignore')).toString());
                 }
 
-                const filesToCopy = getAllFiles(functionPath).map((file) => path.relative(functionPath, file)).filter((file) => !ignorer.ignores(file));
+                const filesToCopy = getAllFiles(functionPath).map((file: string) => path.relative(functionPath, file)).filter((file: string) => !ignorer.ignores(file));
                 for(const f of filesToCopy) {
                     const filePath = path.join(hotSwapPath, f);
                     if (fs.existsSync(filePath)) {
@@ -279,7 +288,7 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
                         file: buildPath
                     }, ['.']);
 
-                await dockerStart(func, allVariables, port);
+                await dockerStart(func, allVariables, portNum!);
             }
         } catch(err) {
             console.error(err);
@@ -300,17 +309,17 @@ const runFunction = async ({ port, functionId, withVariables, reload, userId } =
 
     log('Starting function using Docker ...');
     hint('Function automatically restarts when you edit your code.');
-    await dockerStart(func, allVariables, port);
+    await dockerStart(func, allVariables, portNum!);
 
     Queue.unlock();
 }
 
-const run = new Command("run")
+export const run = new Command("run")
     .description(commandDescriptions['run'])
     .configureHelp({
         helpWidth: process.stdout.columns || 80
     })
-    .action(actionRunner(async (_options, command) => {
+    .action(actionRunner(async (_options: any, command: Command) => {
         command.help();
     }));
 
@@ -325,6 +334,3 @@ run
     .option(`--no-reload`, `Prevent live reloading of server when changes are made to function files`)
     .action(actionRunner(runFunction));
 
-module.exports = {
-    run
-}