appwrite-utils-cli 0.9.993 → 0.9.994

package/README.md

@@ -86,8 +86,6 @@ Available options:
 - `--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
 
 ### Transfer Databases
@@ -149,6 +147,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.994: Added function deployment management, in BETA, and fixed document transfer between databases
 - 0.9.993: Fixed `updateFunctionSpecifications` resetting functions to default with undefined values (oops)
 - 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

package/dist/collections/methods.js

@@ -3,7 +3,7 @@ import { nameToIdMapping, processQueue } from "../migrations/queue.js";
 import { createUpdateCollectionAttributes } from "./attributes.js";
 import { createOrUpdateIndexes } from "./indexes.js";
 import _ from "lodash";
-import { SchemaGenerator } from "../utils/schemaStrings.js";
+import { SchemaGenerator } from "../migrations/schemaStrings.js";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 export const documentExists = async (db, dbId, targetCollectionId, toCreateObject) => {
     // Had to do this because kept running into issues with type checking arrays so, sorry 40ms
@@ -93,7 +93,7 @@ async function wipeDocumentsFromCollection(database, databaseId, collectionId) {
         const docsResponse = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
         documents = documents.concat(docsResponse.documents);
     }
-    const batchDeletePromises = documents.map(doc => database.deleteDocument(databaseId, collectionId, doc.$id));
+    const batchDeletePromises = documents.map((doc) => database.deleteDocument(databaseId, collectionId, doc.$id));
     const maxStackSize = 100;
     for (let i = 0; i < batchDeletePromises.length; i += maxStackSize) {
         await Promise.all(batchDeletePromises.slice(i, i + maxStackSize));
@@ -117,7 +117,9 @@ export const wipeDatabase = async (database, databaseId) => {
     return collectionsDeleted;
 };
 export const wipeCollection = async (database, databaseId, collectionId) => {
-    const collections = await database.listCollections(databaseId, [Query.equal("$id", collectionId)]);
+    const collections = await database.listCollections(databaseId, [
+        Query.equal("$id", collectionId),
+    ]);
     if (collections.total === 0) {
         console.log(`Collection ${collectionId} not found`);
         return;
@@ -141,7 +143,7 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         const permissions = [];
         if (collection.$permissions && collection.$permissions.length > 0) {
             for (const permission of collection.$permissions) {
-                if (typeof permission === 'string') {
+                if (typeof permission === "string") {
                     permissions.push(permission);
                 }
                 else {

package/dist/functions/deployments.d.ts

@@ -0,0 +1,4 @@
+import { Client } from "node-appwrite";
+import { type AppwriteFunction } from "appwrite-utils";
+export declare const deployFunction: (client: Client, functionId: string, codePath: string, activate?: boolean, entrypoint?: string, commands?: string) => Promise<import("node-appwrite").Models.Deployment>;
+export declare const deployLocalFunction: (client: Client, functionName: string, functionConfig: AppwriteFunction, functionPath?: string) => Promise<import("node-appwrite").Models.Deployment>;

package/dist/functions/deployments.js

@@ -0,0 +1,114 @@
+import { Client, Functions, 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";
+import cliProgress from "cli-progress";
+import { execSync } from "child_process";
+import { createFunction, getFunction, updateFunctionSpecifications, } from "./methods.js";
+const findFunctionDirectory = (basePath, functionName) => {
+    const normalizedName = functionName.toLowerCase().replace(/\s+/g, "-");
+    const dirs = fs.readdirSync(basePath, { withFileTypes: true });
+    for (const dir of dirs) {
+        if (dir.isDirectory()) {
+            const fullPath = join(basePath, dir.name);
+            if (dir.name.toLowerCase() === normalizedName) {
+                return fullPath;
+            }
+            const nestedResult = findFunctionDirectory(fullPath, functionName);
+            if (nestedResult) {
+                return nestedResult;
+            }
+        }
+    }
+    return undefined;
+};
+export const deployFunction = async (client, functionId, codePath, activate = true, entrypoint = "index.js", commands = "npm install") => {
+    const functions = new Functions(client);
+    console.log(chalk.blue("📦 Preparing function deployment..."));
+    const progressBar = new cliProgress.SingleBar({
+        format: "Uploading |" +
+            chalk.cyan("{bar}") +
+            "| {percentage}% | {value}/{total} Chunks",
+        barCompleteChar: "█",
+        barIncompleteChar: "░",
+        hideCursor: true,
+    });
+    const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
+    await createTarball({
+        gzip: true,
+        file: tarPath,
+        cwd: codePath,
+    }, ["."]);
+    const fileBuffer = await fs.promises.readFile(tarPath);
+    const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
+    try {
+        console.log(chalk.blue("🚀 Creating deployment..."));
+        const functionResponse = await functions.createDeployment(functionId, fileObject, activate, entrypoint, commands, (progress) => {
+            const chunks = progress.chunksUploaded;
+            const total = progress.chunksTotal;
+            if (chunks && total) {
+                if (chunks === 0) {
+                    progressBar.start(total, 0);
+                }
+                else if (chunks === total) {
+                    progressBar.update(total);
+                    progressBar.stop();
+                    console.log(chalk.green("✅ Upload complete!"));
+                }
+                else {
+                    progressBar.update(chunks);
+                }
+            }
+        });
+        await fs.promises.unlink(tarPath);
+        console.log(chalk.green("✨ Function deployed successfully!"));
+        return functionResponse;
+    }
+    catch (error) {
+        progressBar.stop();
+        console.error(chalk.red("❌ Deployment failed:"), error);
+        throw error;
+    }
+};
+export const deployLocalFunction = async (client, functionName, functionConfig, functionPath) => {
+    let functionExists = true;
+    try {
+        await getFunction(client, functionConfig.$id);
+    }
+    catch (error) {
+        functionExists = false;
+    }
+    const resolvedPath = functionPath ||
+        functionConfig.dirPath ||
+        findFunctionDirectory(process.cwd(), functionName) ||
+        join(process.cwd(), "functions", functionName.toLowerCase().replace(/\s+/g, "-"));
+    if (functionConfig.predeployCommands?.length) {
+        console.log(chalk.blue("Executing predeploy commands..."));
+        for (const command of functionConfig.predeployCommands) {
+            try {
+                console.log(chalk.gray(`Executing: ${command}`));
+                execSync(command, {
+                    cwd: resolvedPath,
+                    stdio: "inherit",
+                });
+            }
+            catch (error) {
+                console.error(chalk.red(`Failed to execute predeploy command: ${command}`));
+                throw error;
+            }
+        }
+    }
+    if (!functionExists) {
+        await createFunction(client, functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute, functionConfig.events, functionConfig.schedule, functionConfig.timeout, functionConfig.enabled, functionConfig.logging, functionConfig.entrypoint, functionConfig.commands);
+    }
+    if (functionConfig.specification) {
+        await updateFunctionSpecifications(client, functionConfig.$id, functionConfig.specification);
+    }
+    const deployPath = functionConfig.deployDir
+        ? join(resolvedPath, functionConfig.deployDir)
+        : resolvedPath;
+    return deployFunction(client, functionConfig.$id, deployPath, true, functionConfig.entrypoint, functionConfig.commands);
+};

package/dist/functions/methods.d.ts

@@ -1,10 +1,15 @@
-import { Client, Runtime, type Models } from "node-appwrite";
+import { Client, Runtime } 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 listFunctions: (client: Client, queries?: string[], search?: string) => Promise<import("node-appwrite").Models.FunctionList>;
+export declare const getFunction: (client: Client, functionId: string) => Promise<import("node-appwrite").Models.Function>;
+export declare const downloadLatestFunctionDeployment: (client: Client, functionId: string, basePath?: string) => Promise<{
+    path: string;
+    function: import("node-appwrite").Models.Function;
+    deployment: import("node-appwrite").Models.Deployment;
+}>;
 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>;
+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<import("node-appwrite").Models.Function>;
+export declare const updateFunctionSpecifications: (client: Client, functionId: string, specification: Specification) => Promise<import("node-appwrite").Models.Function | undefined>;
+export declare const listSpecifications: (client: Client) => Promise<import("node-appwrite").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<import("node-appwrite").Models.Function>;
+export declare const createFunctionTemplate: (templateType: "typescript-node" | "poetry" | "count-docs-in-collection", functionName: string, basePath?: string) => Promise<string>;

package/dist/functions/methods.js

@@ -1,10 +1,9 @@
 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";
+import { extract as extractTar } from "tar";
 export const listFunctions = async (client, queries, search) => {
     const functions = new Functions(client);
     const functionsList = await functions.list(queries, search);
@@ -15,6 +14,42 @@ export const getFunction = async (client, functionId) => {
     const functionResponse = await functions.get(functionId);
     return functionResponse;
 };
+export const downloadLatestFunctionDeployment = async (client, functionId, basePath = process.cwd()) => {
+    const functions = new Functions(client);
+    const functionInfo = await getFunction(client, functionId);
+    const functionDeployments = await functions.listDeployments(functionId, [
+        Query.orderDesc("$createdAt"),
+    ]);
+    if (functionDeployments.deployments.length === 0) {
+        throw new Error("No deployments found for function");
+    }
+    const latestDeployment = functionDeployments.deployments[0];
+    const deploymentData = await functions.getDeploymentDownload(functionId, latestDeployment.$id);
+    // Create function directory using provided basePath
+    const functionDir = join(basePath, functionInfo.name.toLowerCase().replace(/\s+/g, "-"));
+    await fs.promises.mkdir(functionDir, { recursive: true });
+    // Create temporary file for tar extraction
+    const tarPath = join(functionDir, "temp.tar.gz");
+    const uint8Array = new Uint8Array(deploymentData);
+    await fs.promises.writeFile(tarPath, uint8Array);
+    try {
+        // Extract tar file
+        extractTar({
+            C: functionDir,
+            file: tarPath,
+            sync: true,
+        });
+        return {
+            path: functionDir,
+            function: functionInfo,
+            deployment: latestDeployment,
+        };
+    }
+    finally {
+        // Clean up tar file
+        await fs.promises.unlink(tarPath).catch(() => { });
+    }
+};
 export const deleteFunction = async (client, functionId) => {
     const functions = new Functions(client);
     const functionResponse = await functions.delete(functionId);
@@ -58,22 +93,41 @@ export const updateFunction = async (client, functionId, name, runtime, execute,
     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;
+export const createFunctionTemplate = async (templateType, functionName, basePath = "./functions") => {
+    const functionPath = join(basePath, functionName);
+    const templatesPath = join(__dirname, "templates", templateType);
+    // Create function directory
+    await fs.promises.mkdir(functionPath, { recursive: true });
+    // Copy template files recursively
+    const copyTemplateFiles = async (sourcePath, targetPath) => {
+        const entries = await fs.promises.readdir(sourcePath, {
+            withFileTypes: true,
+        });
+        for (const entry of entries) {
+            const srcPath = join(sourcePath, entry.name);
+            const destPath = join(targetPath, entry.name);
+            if (entry.isDirectory()) {
+                await fs.promises.mkdir(destPath, { recursive: true });
+                await copyTemplateFiles(srcPath, destPath);
+            }
+            else {
+                let content = await fs.promises.readFile(srcPath, "utf-8");
+                // Replace template variables
+                content = content
+                    .replace(/\{\{functionName\}\}/g, functionName)
+                    .replace(/\{\{databaseId\}\}/g, "{{databaseId}}")
+                    .replace(/\{\{collectionId\}\}/g, "{{collectionId}}");
+                await fs.promises.writeFile(destPath, content);
+            }
+        }
+    };
+    try {
+        await copyTemplateFiles(templatesPath, functionPath);
+        console.log(chalk.green(`✨ Created ${templateType} function template at ${functionPath}`));
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to create function template: ${error}`));
+        throw error;
+    }
+    return functionPath;
 };

package/dist/functions/templates/count-docs-in-collection/src/main.d.ts

@@ -0,0 +1,21 @@
+import { AppwriteRequest, AppwriteResponse } from "appwrite-utils";
+/**
+ * Main function to handle document counting requests.
+ * @param {Object} params - The function parameters.
+ * @param {Object} params.req - The request object.
+ * @param {Object} params.res - The response object.
+ * @param {Function} params.log - Logging function.
+ * @param {Function} params.error - Error logging function.
+ * @returns {Promise<Object>} JSON response with count or error message.
+ */
+declare const _default: ({ req, res, log, error }: {
+    req: AppwriteRequest;
+    res: AppwriteResponse;
+    log: (message: string) => void;
+    error: (message: string) => void;
+}) => Promise<{
+    body: Uint8Array;
+    statusCode: number;
+    headers: Record<string, string>;
+}>;
+export default _default;

package/dist/functions/templates/count-docs-in-collection/src/main.js

@@ -0,0 +1,114 @@
+import { Client, Databases, Query } from "node-appwrite";
+import { AppwriteRequest, AppwriteResponse } from "appwrite-utils";
+import { requestSchema } from "./request.js";
+/**
+ * Main function to handle document counting requests.
+ * @param {Object} params - The function parameters.
+ * @param {Object} params.req - The request object.
+ * @param {Object} params.res - The response object.
+ * @param {Function} params.log - Logging function.
+ * @param {Function} params.error - Error logging function.
+ * @returns {Promise<Object>} JSON response with count or error message.
+ */
+export default async ({ req, res, log, error }) => {
+    // Initialize Appwrite client
+    const client = new Client()
+        .setEndpoint(process.env["APPWRITE_FUNCTION_ENDPOINT"])
+        .setProject(process.env["APPWRITE_FUNCTION_PROJECT_ID"])
+        .setKey(req.headers["x-appwrite-key"] || "");
+    const databases = new Databases(client);
+    try {
+        if (req.method === "POST") {
+            // Parse request body
+            const body = requestSchema.safeParse(typeof req.body === "string" ? JSON.parse(req.body) : req.body);
+            if (!body.success) {
+                return res.json({ success: false, error: body.error }, 400);
+            }
+            const { databaseId, collectionId, queries = [] } = body.data;
+            log(`Queries: ${JSON.stringify(queries)}`);
+            // Count documents in the specified collection
+            const count = await countAllDocuments(log, databases, databaseId, collectionId, queries);
+            // Return successful response with document count
+            return res.json({
+                success: true,
+                count: count,
+            });
+        }
+        else {
+            // Return error for non-POST requests
+            return res.json({ success: false, error: "Method not allowed" }, 405);
+        }
+    }
+    catch (err) {
+        // Log and return any errors
+        error(`Error processing request: ${err}`);
+        return res.json({ success: false, error: err.message }, 500);
+    }
+};
+/**
+ * Counts all documents in a collection, handling large collections efficiently.
+ * @param {Function} log - Logging function.
+ * @param {Databases} databases - Appwrite Databases instance.
+ * @param {string} databaseId - ID of the database.
+ * @param {string} collectionId - ID of the collection.
+ * @param {string[]} queries - Array of query strings to filter documents.
+ * @param {number} batchSize - Size of batches for processing (default: 1000).
+ * @returns {Promise<number>} Total count of documents.
+ */
+async function countAllDocuments(log, databases, databaseId, collectionId, queries = [], batchSize = 1000) {
+    // Filter out limit and offset queries
+    const initialQueries = queries.filter((q) => !(q.includes("limit") || q.includes("offset")));
+    // Initial query to check if total is less than 5000
+    const initialResponse = await databases.listDocuments(databaseId, collectionId, [...initialQueries, Query.limit(1)]);
+    if (initialResponse.total < 5000) {
+        log(`Total documents (from initial response): ${initialResponse.total}`);
+        return initialResponse.total;
+    }
+    // If total is 5000 or more, we need to count manually
+    let bound = 5000;
+    // Exponential search to find an upper bound
+    while (true) {
+        log(`Querying for offset ${bound}`);
+        try {
+            const response = await databases.listDocuments(databaseId, collectionId, [
+                ...initialQueries,
+                Query.limit(1),
+                Query.offset(bound),
+            ]);
+            if (response.documents.length === 0) {
+                break;
+            }
+            bound *= 2;
+        }
+        catch (error) {
+            break;
+        }
+    }
+    // Binary search to find the exact count
+    let low = Math.floor(bound / 2);
+    let high = bound;
+    let lastValidCount = low;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        log(`Binary search: Querying for offset ${mid}`);
+        try {
+            const response = await databases.listDocuments(databaseId, collectionId, [
+                ...initialQueries,
+                Query.limit(1),
+                Query.offset(mid),
+            ]);
+            if (response.documents.length > 0) {
+                lastValidCount = mid + 1; // +1 because offset is 0-based
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        catch (error) {
+            high = mid - 1;
+        }
+    }
+    log(`Total documents: ${lastValidCount}`);
+    return lastValidCount;
+}

package/dist/functions/templates/count-docs-in-collection/src/request.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const requestSchema: z.ZodObject<{
+    databaseId: z.ZodString;
+    collectionId: z.ZodString;
+    queries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    collectionId: string;
+    databaseId: string;
+    queries?: string[] | undefined;
+}, {
+    collectionId: string;
+    databaseId: string;
+    queries?: string[] | undefined;
+}>;
+export type Request = z.infer<typeof requestSchema>;

package/dist/functions/templates/count-docs-in-collection/src/request.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const requestSchema = z.object({
+    databaseId: z.string(),
+    collectionId: z.string(),
+    queries: z.array(z.string()).optional(),
+});

package/dist/functions/templates/typescript-node/src/index.d.ts

@@ -0,0 +1,11 @@
+import { AppwriteRequest, AppwriteResponse } from "appwrite-utils";
+export default function ({ req, res, log, error, }: {
+    req: AppwriteRequest;
+    res: AppwriteResponse;
+    log: (message: string) => void;
+    error: (message: string) => void;
+}): Promise<{
+    body: Uint8Array;
+    statusCode: number;
+    headers: Record<string, string>;
+}>;

package/dist/functions/templates/typescript-node/src/index.js

@@ -0,0 +1,11 @@
+import { Client } from "node-appwrite";
+import { AppwriteRequest, AppwriteResponse } from "appwrite-utils";
+export default async function ({ req, res, log, error, }) {
+    const client = new Client()
+        .setEndpoint(process.env["APPWRITE_FUNCTION_ENDPOINT"])
+        .setProject(process.env["APPWRITE_FUNCTION_PROJECT_ID"])
+        .setKey(req.headers["x-appwrite-key"] || "");
+    return res.json({
+        message: "Hello from TypeScript function!",
+    });
+}

package/dist/interactiveCLI.d.ts

@@ -6,6 +6,12 @@ export declare class InteractiveCLI {
     private initControllerIfNeeded;
     private selectDatabases;
     private selectCollections;
+    private createFunction;
+    private findFunctionInSubdirectories;
+    private deployFunction;
+    private deleteFunction;
+    private selectFunctions;
+    private getLocalFunctions;
     private selectBuckets;
     private createCollectionConfig;
     private configureBuckets;