appwrite-utils-cli 0.10.1 → 0.10.3

package/README.md

@@ -147,6 +147,8 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.10.03: Fixed `syncDb` to push the configurations properly, accidentally hurt it during `synchronizeConfigurations`
+- 0.10.02: Updated `wipeCollection` to handle errors gracefully
 - 0.10.01: Fixed `predeployCommands` to work
 - 0.10.001: Updated `deployFunction` to not updateConfig if it's already present
 - 0.10.0: Fixed `synchronize configurations` for functions, now you do not need to deploy the function first

package/dist/collections/methods.js

@@ -87,19 +87,40 @@ export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) =>
     }
 };
 async function wipeDocumentsFromCollection(database, databaseId, collectionId) {
-    const initialDocuments = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
-    let documents = initialDocuments.documents;
-    while (documents.length === 1000) {
-        const docsResponse = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
-        documents = documents.concat(docsResponse.documents);
+    try {
+        const initialDocuments = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
+        let documents = initialDocuments.documents;
+        let totalDocuments = documents.length;
+        while (documents.length === 1000) {
+            const docsResponse = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
+            documents = documents.concat(docsResponse.documents);
+            totalDocuments = documents.length;
+        }
+        console.log(`Found ${totalDocuments} documents to delete`);
+        const maxStackSize = 25; // Reduced batch size
+        for (let i = 0; i < documents.length; i += maxStackSize) {
+            const batch = documents.slice(i, i + maxStackSize);
+            const deletePromises = batch.map(async (doc) => {
+                try {
+                    await database.deleteDocument(databaseId, collectionId, doc.$id);
+                }
+                catch (error) {
+                    // Skip if document doesn't exist or other non-critical errors
+                    if (!error.message?.includes("Document with the requested ID could not be found")) {
+                        console.error(`Failed to delete document ${doc.$id}:`, error.message);
+                    }
+                }
+            });
+            await Promise.all(deletePromises);
+            await delay(250); // Increased delay between batches
+            console.log(`Deleted batch of ${batch.length} documents (${i + batch.length}/${totalDocuments})`);
+        }
+        console.log(`Completed deletion of ${totalDocuments} documents from collection ${collectionId}`);
     }
-    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));
-        await delay(100);
+    catch (error) {
+        console.error(`Error wiping documents from collection ${collectionId}:`, error);
+        throw error;
     }
-    console.log(`Deleted ${documents.length} documents from collection ${collectionId}`);
 }
 export const wipeDatabase = async (database, databaseId) => {
     console.log(`Wiping database: ${databaseId}`);

package/dist/interactiveCLI.js

@@ -718,28 +718,46 @@ export class InteractiveCLI {
         }, bucketId.length > 0 ? bucketId : ulid());
     }
     async syncDb() {
-        console.log(chalk.yellow("Syncing database..."));
-        const functionsClient = new Functions(this.controller.appwriteServer);
-        const databases = await this.selectDatabases(await fetchAllDatabases(this.controller.database), chalk.blue("Select databases to synchronize:"), true);
-        const collections = await this.selectCollections(databases[0], this.controller.database, chalk.blue("Select collections to synchronize:"), true, true // prefer local
+        console.log(chalk.blue("Pushing local configuration to Appwrite..."));
+        const databases = await this.selectDatabases(this.getLocalDatabases(), chalk.blue("Select local databases to push:"), true);
+        if (!databases.length) {
+            console.log(chalk.yellow("No databases selected. Skipping database sync."));
+            return;
+        }
+        const collections = await this.selectCollections(databases[0], this.controller.database, chalk.blue("Select local collections to push:"), true, true // prefer local
         );
-        const answer = await inquirer.prompt([
+        const { syncFunctions } = await inquirer.prompt([
             {
                 type: "confirm",
                 name: "syncFunctions",
-                message: "Do you want to synchronize functions?",
+                message: "Do you want to push local functions to remote?",
                 default: false,
             },
         ]);
-        if (answer.syncFunctions) {
-            const functions = await this.selectFunctions(chalk.blue("Select functions to synchronize:"), true, true // prefer local
-            );
+        try {
+            // First sync databases and collections
             await this.controller.syncDb(databases, collections);
-            for (const func of functions) {
-                await deployLocalFunction(this.controller.appwriteServer, func.dirPath || `functions/${func.name}`, func);
+            console.log(chalk.green("Database and collections pushed successfully"));
+            // Then handle functions if requested
+            if (syncFunctions && this.controller.config?.functions?.length) {
+                const functions = await this.selectFunctions(chalk.blue("Select local functions to push:"), true, true // prefer local
+                );
+                for (const func of functions) {
+                    try {
+                        await this.controller.deployFunction(func.name);
+                        console.log(chalk.green(`Function ${func.name} deployed successfully`));
+                    }
+                    catch (error) {
+                        console.error(chalk.red(`Failed to deploy function ${func.name}:`), error);
+                    }
+                }
             }
+            console.log(chalk.green("Local configuration push completed successfully!"));
+        }
+        catch (error) {
+            console.error(chalk.red("Failed to push local configuration:"), error);
+            throw error;
         }
-        console.log(chalk.green("Database sync completed."));
     }
     async synchronizeConfigurations() {
         console.log(chalk.blue("Synchronizing configurations..."));

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.10.01",
+  "version": "0.10.03",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/collections/methods.ts

@@ -129,31 +129,68 @@ async function wipeDocumentsFromCollection(
   databaseId: string,
   collectionId: string
 ) {
-  const initialDocuments = await database.listDocuments(
-    databaseId,
-    collectionId,
-    [Query.limit(1000)]
-  );
-  let documents = initialDocuments.documents;
-  while (documents.length === 1000) {
-    const docsResponse = await database.listDocuments(
+  try {
+    const initialDocuments = 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 maxStackSize = 100;
-  for (let i = 0; i < batchDeletePromises.length; i += maxStackSize) {
-    await Promise.all(batchDeletePromises.slice(i, i + maxStackSize));
-    await delay(100);
+    let documents = initialDocuments.documents;
+    let totalDocuments = documents.length;
+
+    while (documents.length === 1000) {
+      const docsResponse = await database.listDocuments(
+        databaseId,
+        collectionId,
+        [Query.limit(1000)]
+      );
+      documents = documents.concat(docsResponse.documents);
+      totalDocuments = documents.length;
+    }
+
+    console.log(`Found ${totalDocuments} documents to delete`);
+
+    const maxStackSize = 25; // Reduced batch size
+    for (let i = 0; i < documents.length; i += maxStackSize) {
+      const batch = documents.slice(i, i + maxStackSize);
+      const deletePromises = batch.map(async (doc) => {
+        try {
+          await database.deleteDocument(databaseId, collectionId, doc.$id);
+        } catch (error: any) {
+          // Skip if document doesn't exist or other non-critical errors
+          if (
+            !error.message?.includes(
+              "Document with the requested ID could not be found"
+            )
+          ) {
+            console.error(
+              `Failed to delete document ${doc.$id}:`,
+              error.message
+            );
+          }
+        }
+      });
+
+      await Promise.all(deletePromises);
+      await delay(250); // Increased delay between batches
+
+      console.log(
+        `Deleted batch of ${batch.length} documents (${
+          i + batch.length
+        }/${totalDocuments})`
+      );
+    }
+
+    console.log(
+      `Completed deletion of ${totalDocuments} documents from collection ${collectionId}`
+    );
+  } catch (error) {
+    console.error(
+      `Error wiping documents from collection ${collectionId}:`,
+      error
+    );
+    throw error;
   }
-  console.log(
-    `Deleted ${documents.length} documents from collection ${collectionId}`
-  );
 }
 
 export const wipeDatabase = async (

package/src/interactiveCLI.ts

@@ -977,44 +977,73 @@ export class InteractiveCLI {
   }
 
   private async syncDb(): Promise<void> {
-    console.log(chalk.yellow("Syncing database..."));
-    const functionsClient = new Functions(this.controller!.appwriteServer!);
+    console.log(chalk.blue("Pushing local configuration to Appwrite..."));
+
     const databases = await this.selectDatabases(
-      await fetchAllDatabases(this.controller!.database!),
-      chalk.blue("Select databases to synchronize:"),
+      this.getLocalDatabases(),
+      chalk.blue("Select local databases to push:"),
       true
     );
+
+    if (!databases.length) {
+      console.log(
+        chalk.yellow("No databases selected. Skipping database sync.")
+      );
+      return;
+    }
+
     const collections = await this.selectCollections(
       databases[0],
       this.controller!.database!,
-      chalk.blue("Select collections to synchronize:"),
+      chalk.blue("Select local collections to push:"),
       true,
       true // prefer local
     );
-    const answer = await inquirer.prompt([
+
+    const { syncFunctions } = await inquirer.prompt([
       {
         type: "confirm",
         name: "syncFunctions",
-        message: "Do you want to synchronize functions?",
+        message: "Do you want to push local functions to remote?",
         default: false,
       },
     ]);
-    if (answer.syncFunctions) {
-      const functions = await this.selectFunctions(
-        chalk.blue("Select functions to synchronize:"),
-        true,
-        true // prefer local
-      );
+
+    try {
+      // First sync databases and collections
       await this.controller!.syncDb(databases, collections);
-      for (const func of functions) {
-        await deployLocalFunction(
-          this.controller!.appwriteServer!,
-          func.dirPath || `functions/${func.name}`,
-          func
+      console.log(chalk.green("Database and collections pushed successfully"));
+
+      // Then handle functions if requested
+      if (syncFunctions && this.controller!.config?.functions?.length) {
+        const functions = await this.selectFunctions(
+          chalk.blue("Select local functions to push:"),
+          true,
+          true // prefer local
         );
+
+        for (const func of functions) {
+          try {
+            await this.controller!.deployFunction(func.name);
+            console.log(
+              chalk.green(`Function ${func.name} deployed successfully`)
+            );
+          } catch (error) {
+            console.error(
+              chalk.red(`Failed to deploy function ${func.name}:`),
+              error
+            );
+          }
+        }
       }
+
+      console.log(
+        chalk.green("Local configuration push completed successfully!")
+      );
+    } catch (error) {
+      console.error(chalk.red("Failed to push local configuration:"), error);
+      throw error;
     }
-    console.log(chalk.green("Database sync completed."));
   }
 
   private async synchronizeConfigurations(): Promise<void> {

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

@@ -1,21 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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!",
-    });
-}