appwrite-utils-cli 0.9.990 → 0.9.992

package/README.md

@@ -82,6 +82,11 @@ Available options:
 - `--remoteProjectId`: Set the remote Appwrite project ID for transfers
 - `--remoteApiKey`: Set the remote Appwrite API key for transfers
 - `--setup`: Create setup files
+- `--updateFunctionSpec`: Update function specifications
+- `--functionId`: Function ID to update
+- `--specification`: New function specification (one of: s-0.5vcpu-512mb, s-1vcpu-1gb, s-2vcpu-2gb, s-2vcpu-4gb, s-4vcpu-4gb, s-4vcpu-8gb, s-8vcpu-4gb, s-8vcpu-8gb)
+
+
 
 ## Examples
 
@@ -109,6 +114,25 @@ Transfer files between buckets:
 npx appwrite-utils-cli appwrite-migrate --transfer --fromBucketId sourceBucketId --toBucketId targetBucketId --remoteEndpoint https://appwrite.otherserver.com --remoteProjectId yourProjectId --remoteApiKey yourApiKey
 ```
 
+### Update Function Specifications
+
+Update the CPU and RAM specifications for a function:
+
+```bash
+npx appwrite-utils-cli appwrite-migrate --updateFunctionSpec --functionId yourFunctionId --specification s-1vcpu-1gb
+```
+
+Available specifications:
+
+- s-0.5vcpu-512mb: 0.5 vCPU, 512MB RAM
+- s-1vcpu-1gb: 1 vCPU, 1GB RAM
+- s-2vcpu-2gb: 2 vCPU, 2GB RAM
+- s-2vcpu-4gb: 2 vCPU, 4GB RAM
+- s-4vcpu-4gb: 4 vCPU, 4GB RAM
+- s-4vcpu-8gb: 4 vCPU, 8GB RAM
+- s-8vcpu-4gb: 8 vCPU, 4GB RAM
+- s-8vcpu-8gb: 8 vCPU, 8GB RAM
+
 ## Additional Notes
 
 - If you run out of RAM during large data imports, you can increase Node's memory allocation:
@@ -125,6 +149,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.992: Added `updateFunctionSpecifications` which lists functions and specifications to allow you to update your functions max CPU and RAM usage per-function
 - 0.9.990: Fixed `transferFilesLocalToLocal` and `remote` if a document exists with that `$id`, also fixed wipe `"all"` option also wiping the associated buckets
 - 0.9.983: Fixed `afterImportActions` not resolving
 - 0.9.981: Try fixing `tryAwaitWithRetry` to catch `522` errors from Cloudflare, they were appearing for some users, also added a 1000ms delay to `tryAwaitWithRetry`

package/dist/functions/methods.d.ts

@@ -0,0 +1,10 @@
+import { Client, Runtime, type Models } from "node-appwrite";
+import { type Specification } from "appwrite-utils";
+export declare const listFunctions: (client: Client, queries?: string[], search?: string) => Promise<Models.FunctionList>;
+export declare const getFunction: (client: Client, functionId: string) => Promise<Models.Function>;
+export declare const deleteFunction: (client: Client, functionId: string) => Promise<{}>;
+export declare const createFunction: (client: Client, functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, templateRepository?: string, templateOwner?: string, templateRootDirectory?: string, templateVersion?: string, specification?: string) => Promise<Models.Function>;
+export declare const updateFunctionSpecifications: (client: Client, functionId: string, specification: Specification) => Promise<Models.Function | undefined>;
+export declare const listSpecifications: (client: Client) => Promise<Models.SpecificationList>;
+export declare const updateFunction: (client: Client, functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: Specification) => Promise<Models.Function>;
+export declare const deployFunction: (client: Client, functionId: string, codePath: string, activate?: boolean, entrypoint?: string, commands?: string) => Promise<Models.Deployment>;

package/dist/functions/methods.js

@@ -0,0 +1,79 @@
+import { AppwriteException, Client, Functions, Query, Runtime, } from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
+import { create as createTarball } from "tar";
+import { join } from "node:path";
+import fs from "node:fs";
+import {} from "appwrite-utils";
+import chalk from "chalk";
+export const listFunctions = async (client, queries, search) => {
+    const functions = new Functions(client);
+    const functionsList = await functions.list(queries, search);
+    return functionsList;
+};
+export const getFunction = async (client, functionId) => {
+    const functions = new Functions(client);
+    const functionResponse = await functions.get(functionId);
+    return functionResponse;
+};
+export const deleteFunction = async (client, functionId) => {
+    const functions = new Functions(client);
+    const functionResponse = await functions.delete(functionId);
+    return functionResponse;
+};
+export const createFunction = async (client, functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, templateRepository, templateOwner, templateRootDirectory, templateVersion, specification) => {
+    const functions = new Functions(client);
+    const functionResponse = await functions.create(functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, templateRepository, templateOwner, templateRootDirectory, templateVersion, specification);
+    return functionResponse;
+};
+export const updateFunctionSpecifications = async (client, functionId, specification) => {
+    const curFunction = await listFunctions(client, [
+        Query.equal("$id", functionId),
+    ]);
+    if (curFunction.functions.length === 0) {
+        throw new Error("Function not found");
+    }
+    const functionFound = curFunction.functions[0];
+    try {
+        const functionResponse = await updateFunction(client, functionId, functionFound.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, specification);
+        return functionResponse;
+    }
+    catch (error) {
+        if (error instanceof AppwriteException &&
+            error.message.includes("Invalid `specification`")) {
+            console.error(chalk.red("Error updating function specifications, please try setting the env variable `_FUNCTIONS_CPUS` and `_FUNCTIONS_RAM` to non-zero values"));
+        }
+        else {
+            console.error(chalk.red("Error updating function specifications."));
+            throw error;
+        }
+    }
+};
+export const listSpecifications = async (client) => {
+    const functions = new Functions(client);
+    const specifications = await functions.listSpecifications();
+    return specifications;
+};
+export const updateFunction = async (client, functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, specification) => {
+    const functions = new Functions(client);
+    const functionResponse = await functions.update(functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, specification);
+    return functionResponse;
+};
+export const deployFunction = async (client, functionId, codePath, activate = true, entrypoint = "index.js", commands = "npm install") => {
+    const functions = new Functions(client);
+    // Create temporary tar.gz file
+    const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
+    await createTarball({
+        gzip: true,
+        file: tarPath,
+        cwd: codePath,
+    }, ["."] // Include all files from codePath
+    );
+    // Read the tar.gz file and create a File object
+    const fileBuffer = await fs.promises.readFile(tarPath);
+    const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
+    // Create deployment with the File object
+    const functionResponse = await functions.createDeployment(functionId, fileObject, activate, entrypoint, commands);
+    // Clean up the temporary tar file
+    await fs.promises.unlink(tarPath);
+    return functionResponse;
+};

package/dist/interactiveCLI.d.ts

@@ -21,4 +21,5 @@ export declare class InteractiveCLI {
     private getLocalCollections;
     private getLocalDatabases;
     private reloadConfig;
+    private updateFunctionSpec;
 }

package/dist/interactiveCLI.js

@@ -10,6 +10,7 @@ import { parseAttribute, PermissionToAppwritePermission, } from "appwrite-utils"
 import { ulid } from "ulidx";
 import chalk from "chalk";
 import { DateTime } from "luxon";
+import { listFunctions, listSpecifications } from "./functions/methods.js";
 var CHOICES;
 (function (CHOICES) {
     CHOICES["CREATE_COLLECTION_CONFIG"] = "Create collection config file";
@@ -24,6 +25,7 @@ var CHOICES;
     CHOICES["GENERATE_SCHEMAS"] = "Generate schemas";
     CHOICES["IMPORT_DATA"] = "Import data";
     CHOICES["RELOAD_CONFIG"] = "Reload configuration files";
+    CHOICES["UPDATE_FUNCTION_SPEC"] = "Update function specifications";
     CHOICES["EXIT"] = "Exit";
 })(CHOICES || (CHOICES = {}));
 export class InteractiveCLI {
@@ -91,6 +93,10 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await this.reloadConfig();
                     break;
+                case CHOICES.UPDATE_FUNCTION_SPEC:
+                    await this.initControllerIfNeeded();
+                    await this.updateFunctionSpec();
+                    break;
                 case CHOICES.EXIT:
                     console.log(chalk.green("Goodbye!"));
                     return;
@@ -141,7 +147,7 @@ export class InteractiveCLI {
                 name: "selectedDatabases",
                 message: chalk.blue(message),
                 choices,
-                loop: false,
+                loop: true,
                 pageSize: 10,
             },
         ]);
@@ -190,7 +196,7 @@ export class InteractiveCLI {
                 name: "selectedCollections",
                 message: chalk.blue(message),
                 choices,
-                loop: false,
+                loop: true,
                 pageSize: 10,
             },
         ]);
@@ -689,4 +695,42 @@ export class InteractiveCLI {
             console.error(chalk.red("Error reloading configuration files:"), error);
         }
     }
+    async updateFunctionSpec() {
+        const functions = await listFunctions(this.controller.appwriteServer, [
+            Query.limit(1000),
+        ]);
+        const functionsToUpdate = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'functionId',
+                message: 'Select functions to update:',
+                choices: functions.functions.map(f => ({
+                    name: `${f.name} (${f.$id})`,
+                    value: f.$id
+                })),
+                loop: true,
+            }
+        ]);
+        const specifications = await listSpecifications(this.controller.appwriteServer);
+        const { specification } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'specification',
+                message: 'Select new specification:',
+                choices: specifications.specifications.map((s) => ({
+                    name: `${s.slug}`,
+                    value: s.slug
+                })),
+            }
+        ]);
+        try {
+            for (const functionId of functionsToUpdate.functionId) {
+                await this.controller.updateFunctionSpecifications(functionId, specification);
+                console.log(chalk.green(`Successfully updated function specification to ${specification}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error updating function specification:'), error);
+        }
+    }
 }

package/dist/main.js

@@ -9,6 +9,8 @@ import { getClient } from "./utils/getClientFromConfig.js";
 import { fetchAllDatabases } from "./migrations/databases.js";
 import { setupDirsFiles } from "./utils/setupFiles.js";
 import { fetchAllCollections } from "./collections/methods.js";
+import chalk from "chalk";
+import { listSpecifications } from "./functions/methods.js";
 const argv = yargs(hideBin(process.argv))
     .option("it", {
     alias: ["interactive", "i"],
@@ -119,6 +121,28 @@ const argv = yargs(hideBin(process.argv))
     .option("setup", {
     type: "boolean",
     description: "Setup directories and files",
+})
+    .option("updateFunctionSpec", {
+    type: "boolean",
+    description: "Update function specifications",
+})
+    .option("functionId", {
+    type: "string",
+    description: "Function ID to update",
+})
+    .option("specification", {
+    type: "string",
+    description: "New function specification (e.g., 's-1vcpu-1gb')",
+    choices: [
+        "s-0.5vcpu-512mb",
+        "s-1vcpu-1gb",
+        "s-2vcpu-2gb",
+        "s-2vcpu-4gb",
+        "s-4vcpu-4gb",
+        "s-4vcpu-8gb",
+        "s-8vcpu-4gb",
+        "s-8vcpu-8gb"
+    ],
 })
     .parse();
 async function main() {
@@ -148,6 +172,18 @@ async function main() {
             shouldWriteFile: parsedArgv.writeData,
             wipeCollections: parsedArgv.wipeCollections,
         };
+        if (parsedArgv.updateFunctionSpec) {
+            if (!parsedArgv.functionId || !parsedArgv.specification) {
+                throw new Error("Function ID and specification are required for updating function specs");
+            }
+            console.log(chalk.yellow(`Updating function specification for ${parsedArgv.functionId} to ${parsedArgv.specification}, checking if specification exists...`));
+            const specifications = await listSpecifications(controller.appwriteServer);
+            if (!specifications.specifications.some((s) => s.slug === parsedArgv.specification)) {
+                console.log(chalk.red(`Specification ${parsedArgv.specification} not found`));
+                return;
+            }
+            await controller.updateFunctionSpecifications(parsedArgv.functionId, parsedArgv.specification);
+        }
         // Add default databases if not specified
         if (!options.databases || options.databases.length === 0) {
             const allDatabases = await fetchAllDatabases(controller.database);
@@ -171,19 +207,30 @@ async function main() {
             options.wipeDocumentStorage ||
             options.wipeUsers ||
             options.wipeCollections) {
-            if (options.wipeDatabase && options.databases) {
-                for (const db of options.databases) {
-                    await controller.wipeDatabase(db, options.wipeDocumentStorage);
+            if (parsedArgv.wipe === "all") {
+                if (options.databases) {
+                    for (const db of options.databases) {
+                        await controller.wipeDatabase(db, true); // true to wipe associated buckets
+                    }
                 }
+                await controller.wipeUsers();
             }
-            if (options.wipeDocumentStorage && parsedArgv.bucketIds) {
-                for (const bucketId of parsedArgv.bucketIds.split(",")) {
-                    await controller.wipeDocumentStorage(bucketId);
+            else if (parsedArgv.wipe === "docs") {
+                if (options.databases) {
+                    for (const db of options.databases) {
+                        await controller.wipeBucketFromDatabase(db);
+                    }
+                }
+                if (parsedArgv.bucketIds) {
+                    for (const bucketId of parsedArgv.bucketIds.split(",")) {
+                        await controller.wipeDocumentStorage(bucketId);
+                    }
                 }
             }
-            if (options.wipeUsers) {
+            else if (parsedArgv.wipe === "users") {
                 await controller.wipeUsers();
             }
+            // Handle specific collection wipes
             if (options.wipeCollections && options.databases) {
                 for (const db of options.databases) {
                     const dbCollections = await fetchAllCollections(db.$id, controller.database);

package/dist/migrations/transfer.js

@@ -65,7 +65,13 @@ export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucke
                 continue;
             }
             const fileToCreate = InputFile.fromBuffer(new Uint8Array(fileData), file.name);
-            await tryAwaitWithRetry(async () => await storage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+            try {
+                await tryAwaitWithRetry(async () => await storage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+            }
+            catch (error) {
+                // File already exists, so we can skip it
+                continue;
+            }
             numberOfFiles++;
         }
     }

package/dist/utilsController.d.ts

@@ -1,5 +1,5 @@
 import { Client, Databases, Storage, type Models } from "node-appwrite";
-import { type AppwriteConfig } from "appwrite-utils";
+import { type AppwriteConfig, type Specification } from "appwrite-utils";
 import { type AfterImportActions, type ConverterFunctions, type ValidationRules } from "appwrite-utils";
 import { type TransferOptions } from "./migrations/transfer.js";
 export interface SetupOptions {
@@ -51,4 +51,5 @@ export declare class UtilsController {
     syncDb(databases?: Models.Database[], collections?: Models.Collection[]): Promise<void>;
     getAppwriteFolderPath(): string;
     transferData(options: TransferOptions): Promise<void>;
+    updateFunctionSpecifications(functionId: string, specification: Specification): Promise<void>;
 }

package/dist/utilsController.js

@@ -14,6 +14,8 @@ import { afterImportActions } from "./migrations/afterImportActions.js";
 import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, } from "./migrations/transfer.js";
 import { getClient } from "./utils/getClientFromConfig.js";
 import { fetchAllDatabases } from "./migrations/databases.js";
+import { updateFunctionSpecifications } from "./functions/methods.js";
+import chalk from "chalk";
 export class UtilsController {
     appwriteFolderPath;
     appwriteConfigPath;
@@ -277,6 +279,14 @@ export class UtilsController {
                 }
             }
         }
-        console.log("Transfer completed");
+        console.log(chalk.green("Transfer completed"));
+    }
+    async updateFunctionSpecifications(functionId, specification) {
+        await this.init();
+        if (!this.appwriteServer)
+            throw new Error("Appwrite server not initialized");
+        console.log(chalk.green(`Updating function specifications for ${functionId} to ${specification}`));
+        await updateFunctionSpecifications(this.appwriteServer, functionId, specification);
+        console.log(chalk.green(`Successfully updated function specifications for ${functionId} to ${specification}`));
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.9.990",
+  "version": "0.9.992",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@types/inquirer": "^9.0.7",
-    "appwrite-utils": "^0.3.95",
+    "appwrite-utils": "^0.3.96",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "inquirer": "^9.3.6",
@@ -40,6 +40,7 @@
     "luxon": "^3.5.0",
     "nanostores": "^0.10.3",
     "node-appwrite": "^14.1.0",
+    "tar": "^7.4.3",
     "tsx": "^4.17.0",
     "ulidx": "^2.4.0",
     "winston": "^3.14.2",

package/src/functions/methods.ts

@@ -0,0 +1,235 @@
+import {
+  AppwriteException,
+  Client,
+  Functions,
+  Query,
+  Runtime,
+  type Models,
+} from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
+import { create as createTarball } from "tar";
+import { join } from "node:path";
+import fs from "node:fs";
+import { type Specification } from "appwrite-utils";
+import chalk from "chalk";
+
+export const listFunctions = async (
+  client: Client,
+  queries?: string[],
+  search?: string
+) => {
+  const functions = new Functions(client);
+  const functionsList = await functions.list(queries, search);
+  return functionsList;
+};
+
+export const getFunction = async (client: Client, functionId: string) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.get(functionId);
+  return functionResponse;
+};
+
+export const deleteFunction = async (client: Client, functionId: string) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.delete(functionId);
+  return functionResponse;
+};
+
+export const createFunction = async (
+  client: Client,
+  functionId: string,
+  name: string,
+  runtime: Runtime,
+  execute?: string[],
+  events?: string[],
+  schedule?: string,
+  timeout?: number,
+  enabled?: boolean,
+  logging?: boolean,
+  entrypoint?: string,
+  commands?: string,
+  scopes?: string[],
+  installationId?: string,
+  providerRepositoryId?: string,
+  providerBranch?: string,
+  providerSilentMode?: boolean,
+  providerRootDirectory?: string,
+  templateRepository?: string,
+  templateOwner?: string,
+  templateRootDirectory?: string,
+  templateVersion?: string,
+  specification?: string
+) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.create(
+    functionId,
+    name,
+    runtime,
+    execute,
+    events,
+    schedule,
+    timeout,
+    enabled,
+    logging,
+    entrypoint,
+    commands,
+    scopes,
+    installationId,
+    providerRepositoryId,
+    providerBranch,
+    providerSilentMode,
+    providerRootDirectory,
+    templateRepository,
+    templateOwner,
+    templateRootDirectory,
+    templateVersion,
+    specification
+  );
+  return functionResponse;
+};
+
+export const updateFunctionSpecifications = async (
+  client: Client,
+  functionId: string,
+  specification: Specification
+) => {
+  const curFunction = await listFunctions(client, [
+    Query.equal("$id", functionId),
+  ]);
+  if (curFunction.functions.length === 0) {
+    throw new Error("Function not found");
+  }
+  const functionFound = curFunction.functions[0];
+  try {
+    const functionResponse = await updateFunction(
+      client,
+      functionId,
+      functionFound.name,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      specification
+    );
+    return functionResponse;
+  } catch (error) {
+    if (
+      error instanceof AppwriteException &&
+      error.message.includes("Invalid `specification`")
+    ) {
+      console.error(
+        chalk.red(
+          "Error updating function specifications, please try setting the env variable `_FUNCTIONS_CPUS` and `_FUNCTIONS_RAM` to non-zero values"
+        )
+      );
+    } else {
+      console.error(chalk.red("Error updating function specifications."));
+      throw error;
+    }
+  }
+};
+
+export const listSpecifications = async (client: Client) => {
+  const functions = new Functions(client);
+  const specifications = await functions.listSpecifications();
+  return specifications;
+};
+
+export const updateFunction = async (
+  client: Client,
+  functionId: string,
+  name: string,
+  runtime?: Runtime,
+  execute?: string[],
+  events?: string[],
+  schedule?: string,
+  timeout?: number,
+  enabled?: boolean,
+  logging?: boolean,
+  entrypoint?: string,
+  commands?: string,
+  scopes?: string[],
+  installationId?: string,
+  providerRepositoryId?: string,
+  providerBranch?: string,
+  providerSilentMode?: boolean,
+  providerRootDirectory?: string,
+  specification?: Specification
+) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.update(
+    functionId,
+    name,
+    runtime,
+    execute,
+    events,
+    schedule,
+    timeout,
+    enabled,
+    logging,
+    entrypoint,
+    commands,
+    scopes,
+    installationId,
+    providerRepositoryId,
+    providerBranch,
+    providerSilentMode,
+    providerRootDirectory,
+    specification
+  );
+  return functionResponse;
+};
+
+export const deployFunction = async (
+  client: Client,
+  functionId: string,
+  codePath: string,
+  activate: boolean = true,
+  entrypoint: string = "index.js",
+  commands: string = "npm install"
+) => {
+  const functions = new Functions(client);
+
+  // Create temporary tar.gz file
+  const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
+  await createTarball(
+    {
+      gzip: true,
+      file: tarPath,
+      cwd: codePath,
+    },
+    ["."] // Include all files from codePath
+  );
+
+  // Read the tar.gz file and create a File object
+  const fileBuffer = await fs.promises.readFile(tarPath);
+  const fileObject = InputFile.fromBuffer(
+    new Uint8Array(fileBuffer),
+    `function-${functionId}.tar.gz`
+  );
+
+  // Create deployment with the File object
+  const functionResponse = await functions.createDeployment(
+    functionId,
+    fileObject,
+    activate,
+    entrypoint,
+    commands
+  );
+
+  // Clean up the temporary tar file
+  await fs.promises.unlink(tarPath);
+
+  return functionResponse;
+};

package/src/interactiveCLI.ts

@@ -23,6 +23,7 @@ import {
 import { ulid } from "ulidx";
 import chalk from "chalk";
 import { DateTime } from "luxon";
+import { listFunctions, listSpecifications } from "./functions/methods.js";
 
 enum CHOICES {
   CREATE_COLLECTION_CONFIG = "Create collection config file",
@@ -37,6 +38,7 @@ enum CHOICES {
   GENERATE_SCHEMAS = "Generate schemas",
   IMPORT_DATA = "Import data",
   RELOAD_CONFIG = "Reload configuration files",
+  UPDATE_FUNCTION_SPEC = "Update function specifications",
   EXIT = "Exit",
 }
 
@@ -112,6 +114,10 @@ export class InteractiveCLI {
           await this.initControllerIfNeeded();
           await this.reloadConfig();
           break;
+        case CHOICES.UPDATE_FUNCTION_SPEC:
+          await this.initControllerIfNeeded();
+          await this.updateFunctionSpec();
+          break;
         case CHOICES.EXIT:
           console.log(chalk.green("Goodbye!"));
           return;
@@ -176,7 +182,7 @@ export class InteractiveCLI {
         name: "selectedDatabases",
         message: chalk.blue(message),
         choices,
-        loop: false,
+        loop: true,
         pageSize: 10,
       },
     ]);
@@ -256,7 +262,7 @@ export class InteractiveCLI {
         name: "selectedCollections",
         message: chalk.blue(message),
         choices,
-        loop: false,
+        loop: true,
         pageSize: 10,
       },
     ]);
@@ -962,4 +968,45 @@ export class InteractiveCLI {
       console.error(chalk.red("Error reloading configuration files:"), error);
     }
   }
+
+  private async updateFunctionSpec(): Promise<void> {
+    const functions = await listFunctions(this.controller!.appwriteServer!, [
+      Query.limit(1000),
+    ]);
+    
+    const functionsToUpdate = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'functionId',
+        message: 'Select functions to update:',
+        choices: functions.functions.map(f => ({
+          name: `${f.name} (${f.$id})`,
+          value: f.$id
+        })),
+        loop: true,
+      }
+    ]);
+
+    const specifications = await listSpecifications(this.controller!.appwriteServer!);
+    const { specification } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'specification',
+        message: 'Select new specification:',
+        choices: specifications.specifications.map((s) => ({
+          name: `${s.slug}`,
+          value: s.slug
+        })),
+      }
+    ]);
+  
+    try { 
+      for (const functionId of functionsToUpdate.functionId) {
+        await this.controller!.updateFunctionSpecifications(functionId, specification);
+        console.log(chalk.green(`Successfully updated function specification to ${specification}`));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error updating function specification:'), error);
+    }
+  }
 }

package/src/main.ts

@@ -10,6 +10,9 @@ import { getClient } from "./utils/getClientFromConfig.js";
 import { fetchAllDatabases } from "./migrations/databases.js";
 import { setupDirsFiles } from "./utils/setupFiles.js";
 import { fetchAllCollections } from "./collections/methods.js";
+import type { Specification } from "appwrite-utils";
+import chalk from "chalk";
+import { listSpecifications } from "./functions/methods.js";
 
 interface CliOptions {
   it?: boolean;
@@ -38,6 +41,9 @@ interface CliOptions {
   remoteProjectId?: string;
   remoteApiKey?: string;
   setup?: boolean;
+  updateFunctionSpec?: boolean;
+  functionId?: string;
+  specification?: string;
 }
 
 type ParsedArgv = ArgumentsCamelCase<CliOptions>;
@@ -157,6 +163,28 @@ const argv = yargs(hideBin(process.argv))
     type: "boolean",
     description: "Setup directories and files",
   })
+  .option("updateFunctionSpec", {
+    type: "boolean",
+    description: "Update function specifications",
+  })
+  .option("functionId", {
+    type: "string",
+    description: "Function ID to update",
+  })
+  .option("specification", {
+    type: "string",
+    description: "New function specification (e.g., 's-1vcpu-1gb')",
+    choices: [
+      "s-0.5vcpu-512mb",
+      "s-1vcpu-1gb",
+      "s-2vcpu-2gb",
+      "s-2vcpu-4gb",
+      "s-4vcpu-4gb",
+      "s-4vcpu-8gb",
+      "s-8vcpu-4gb",
+      "s-8vcpu-8gb"
+    ],
+  })
   .parse() as ParsedArgv;
 
 async function main() {
@@ -181,7 +209,8 @@ async function main() {
       collections: parsedArgv.collectionIds?.split(","),
       doBackup: parsedArgv.backup,
       wipeDatabase: parsedArgv.wipe === "all" || parsedArgv.wipe === "docs",
-      wipeDocumentStorage: parsedArgv.wipe === "all" || parsedArgv.wipe === "storage",
+      wipeDocumentStorage:
+        parsedArgv.wipe === "all" || parsedArgv.wipe === "storage",
       wipeUsers: parsedArgv.wipe === "all" || parsedArgv.wipe === "users",
       generateSchemas: parsedArgv.generate,
       importData: parsedArgv.import,
@@ -189,6 +218,19 @@ async function main() {
       wipeCollections: parsedArgv.wipeCollections,
     };
 
+    if (parsedArgv.updateFunctionSpec) {
+      if (!parsedArgv.functionId || !parsedArgv.specification) {
+        throw new Error("Function ID and specification are required for updating function specs");
+      }
+      console.log(chalk.yellow(`Updating function specification for ${parsedArgv.functionId} to ${parsedArgv.specification}, checking if specification exists...`));
+      const specifications = await listSpecifications(controller.appwriteServer!);
+      if (!specifications.specifications.some((s: { slug: string }) => s.slug === parsedArgv.specification)) {
+        console.log(chalk.red(`Specification ${parsedArgv.specification} not found`));
+        return;
+      }
+      await controller.updateFunctionSpecifications(parsedArgv.functionId, parsedArgv.specification as Specification);
+    }
+
     // Add default databases if not specified
     if (!options.databases || options.databases.length === 0) {
       const allDatabases = await fetchAllDatabases(controller.database!);
@@ -218,19 +260,29 @@ async function main() {
       options.wipeUsers ||
       options.wipeCollections
     ) {
-      if (options.wipeDatabase && options.databases) {
-        for (const db of options.databases) {
-          await controller.wipeDatabase(db, options.wipeDocumentStorage);
+      if (parsedArgv.wipe === "all") {
+        if (options.databases) {
+          for (const db of options.databases) {
+            await controller.wipeDatabase(db, true); // true to wipe associated buckets
+          }
         }
-      }
-      if (options.wipeDocumentStorage && parsedArgv.bucketIds) {
-        for (const bucketId of parsedArgv.bucketIds.split(",")) {
-          await controller.wipeDocumentStorage(bucketId);
+        await controller.wipeUsers();
+      } else if (parsedArgv.wipe === "docs") {
+        if (options.databases) {
+          for (const db of options.databases) {
+            await controller.wipeBucketFromDatabase(db);
+          }
         }
-      }
-      if (options.wipeUsers) {
+        if (parsedArgv.bucketIds) {
+          for (const bucketId of parsedArgv.bucketIds.split(",")) {
+            await controller.wipeDocumentStorage(bucketId);
+          }
+        }
+      } else if (parsedArgv.wipe === "users") {
         await controller.wipeUsers();
       }
+
+      // Handle specific collection wipes
       if (options.wipeCollections && options.databases) {
         for (const db of options.databases) {
           const dbCollections = await fetchAllCollections(

package/src/migrations/transfer.ts

@@ -109,15 +109,20 @@ export const transferStorageLocalToLocal = async (
         new Uint8Array(fileData),
         file.name
       );
-      await tryAwaitWithRetry(
-        async () =>
+      try {
+        await tryAwaitWithRetry(
+          async () =>
           await storage.createFile(
             toBucketId,
             file.$id,
             fileToCreate,
             file.$permissions
           )
-      );
+        );
+      } catch (error: any) {
+        // File already exists, so we can skip it
+        continue;
+      }
       numberOfFiles++;
     }
   }

package/src/utilsController.ts

@@ -1,5 +1,5 @@
 import { Client, Databases, Query, Storage, type Models } from "node-appwrite";
-import { type AppwriteConfig } from "appwrite-utils";
+import { type AppwriteConfig, type Specification } from "appwrite-utils";
 import { loadConfig, findAppwriteConfig } from "./utils/loadConfigs.js";
 import { UsersController } from "./migrations/users.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
@@ -42,6 +42,8 @@ import {
 } from "./migrations/transfer.js";
 import { getClient } from "./utils/getClientFromConfig.js";
 import { fetchAllDatabases } from "./migrations/databases.js";
+import { updateFunctionSpecifications } from "./functions/methods.js";
+import chalk from "chalk";
 
 export interface SetupOptions {
   databases?: Models.Database[];
@@ -404,6 +406,14 @@ export class UtilsController {
       }
     }
 
-    console.log("Transfer completed");
+    console.log(chalk.green("Transfer completed"));
+  }
+
+  async updateFunctionSpecifications(functionId: string, specification: Specification) {
+    await this.init();
+    if (!this.appwriteServer) throw new Error("Appwrite server not initialized");
+    console.log(chalk.green(`Updating function specifications for ${functionId} to ${specification}`));
+    await updateFunctionSpecifications(this.appwriteServer, functionId, specification);
+    console.log(chalk.green(`Successfully updated function specifications for ${functionId} to ${specification}`));
   }
 }