appwrite-utils-cli 0.10.1 → 0.10.2

package/README.md

@@ -147,6 +147,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 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/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.02",
   "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/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!",
-    });
-}