appwrite-utils-cli 0.10.86 → 1.0.2

package/dist/storage/methods.js

@@ -2,10 +2,12 @@ import { Compression, Databases, Permission, Query, Role, Storage, } from "node-
 import { tryAwaitWithRetry } from "appwrite-utils";
 import { getClientFromConfig } from "../utils/getClientFromConfig.js";
 import { ulid } from "ulidx";
-import { logOperation } from "../migrations/helper.js";
-import { splitIntoBatches } from "../migrations/migrationHelper.js";
+import { logOperation } from "../shared/operationLogger.js";
+import { splitIntoBatches } from "../shared/migrationHelpers.js";
 import { retryFailedPromises } from "../utils/retryFailedPromises.js";
 import { InputFile } from "node-appwrite/file";
+import { MessageFormatter, Messages } from "../shared/messageFormatter.js";
+import { ProgressManager } from "../shared/progressManager.js";
 export const getStorage = (config) => {
     const client = getClientFromConfig(config);
     return new Storage(client);
@@ -83,19 +85,37 @@ export const ensureDatabaseConfigBucketsExist = async (storage, config, database
         }
     }
 };
-export const wipeDocumentStorage = async (storage, bucketId) => {
-    console.log(`Wiping storage for bucket ID: ${bucketId}`);
+export const wipeDocumentStorage = async (storage, bucketId, options = {}) => {
+    MessageFormatter.warning(`About to delete all files in bucket: ${bucketId}`);
+    if (!options.skipConfirmation) {
+        const { ConfirmationDialogs } = await import("../shared/confirmationDialogs.js");
+        const confirmed = await ConfirmationDialogs.confirmDestructiveOperation({
+            operation: "Storage Wipe",
+            targets: [bucketId],
+            consequences: [
+                "Delete ALL files in the storage bucket",
+                "This action cannot be undone",
+            ],
+            requireExplicitConfirmation: true,
+            confirmationText: "DELETE FILES",
+        });
+        if (!confirmed) {
+            MessageFormatter.info("Storage wipe cancelled by user");
+            return;
+        }
+    }
+    MessageFormatter.progress(`Scanning files in bucket: ${bucketId}`);
     let moreFiles = true;
     let lastFileId;
     const allFiles = [];
+    // First pass: collect all file IDs
     while (moreFiles) {
-        const queries = [Query.limit(100)]; // Adjust the limit as needed
+        const queries = [Query.limit(100)];
         if (lastFileId) {
             queries.push(Query.cursorAfter(lastFileId));
         }
         const filesPulled = await tryAwaitWithRetry(async () => await storage.listFiles(bucketId, queries));
         if (filesPulled.files.length === 0) {
-            console.log("No files found, done!");
             moreFiles = false;
             break;
         }
@@ -103,16 +123,32 @@ export const wipeDocumentStorage = async (storage, bucketId) => {
             const fileIds = filesPulled.files.map((file) => file.$id);
             allFiles.push(...fileIds);
         }
-        moreFiles = filesPulled.files.length === 100; // Adjust based on the limit
+        moreFiles = filesPulled.files.length === 100;
         if (moreFiles) {
             lastFileId = filesPulled.files[filesPulled.files.length - 1].$id;
         }
     }
-    for (const fileId of allFiles) {
-        console.log(`Deleting file: ${fileId}`);
-        await tryAwaitWithRetry(async () => await storage.deleteFile(bucketId, fileId));
+    if (allFiles.length === 0) {
+        MessageFormatter.info("No files found in bucket");
+        return;
+    }
+    // Second pass: delete files with progress tracking
+    const progress = ProgressManager.create(`wipe-${bucketId}`, allFiles.length, {
+        title: `Deleting files from ${bucketId}`,
+    });
+    try {
+        for (let i = 0; i < allFiles.length; i++) {
+            const fileId = allFiles[i];
+            await tryAwaitWithRetry(async () => await storage.deleteFile(bucketId, fileId));
+            progress.update(i + 1, `Deleted file: ${fileId.slice(0, 20)}...`);
+        }
+        progress.stop();
+        MessageFormatter.success(`All ${MessageFormatter.formatNumber(allFiles.length)} files in bucket ${bucketId} have been deleted`);
+    }
+    catch (error) {
+        progress.fail(error instanceof Error ? error.message : String(error));
+        throw error;
     }
-    console.log(`All files in bucket ${bucketId} have been deleted.`);
 };
 export const initOrGetDocumentStorage = async (storage, config, dbId, bucketName) => {
     const bucketId = bucketName ??
@@ -138,9 +174,9 @@ export const initOrGetBackupStorage = async (config, storage) => {
     }
 };
 export const backupDatabase = async (config, database, databaseId, storage) => {
-    console.log("---------------------------------");
-    console.log("Starting Database Backup of " + databaseId);
-    console.log("---------------------------------");
+    const startTime = Date.now();
+    MessageFormatter.banner("Database Backup", `Backing up database: ${databaseId}`);
+    MessageFormatter.info(Messages.BACKUP_STARTED(databaseId));
     let data = {
         database: "",
         collections: [],
@@ -154,25 +190,57 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
         total: 100,
         error: "",
         status: "in_progress",
-    });
+    }, undefined, config.useMigrations);
+    let progress = null;
+    let totalDocuments = 0;
+    let processedDocuments = 0;
     try {
         const db = await tryAwaitWithRetry(async () => await database.get(databaseId));
         data.database = JSON.stringify(db);
+        // First pass: count collections and documents for progress tracking
+        MessageFormatter.step(1, 3, "Analyzing database structure");
         let lastCollectionId = "";
         let moreCollections = true;
-        let progress = 0;
-        let total = 0;
+        let totalCollections = 0;
+        while (moreCollections) {
+            const collectionResponse = await tryAwaitWithRetry(async () => await database.listCollections(databaseId, [
+                Query.limit(500),
+                ...(lastCollectionId ? [Query.cursorAfter(lastCollectionId)] : []),
+            ]));
+            totalCollections += collectionResponse.collections.length;
+            // Count documents in each collection
+            for (const { $id: collectionId } of collectionResponse.collections) {
+                try {
+                    const documentCount = await tryAwaitWithRetry(async () => (await database.listDocuments(databaseId, collectionId, [Query.limit(1)])).total);
+                    totalDocuments += documentCount;
+                }
+                catch (error) {
+                    MessageFormatter.warning(`Could not count documents in collection ${collectionId}`);
+                }
+            }
+            moreCollections = collectionResponse.collections.length === 500;
+            if (moreCollections) {
+                lastCollectionId = collectionResponse.collections[collectionResponse.collections.length - 1].$id;
+            }
+        }
+        const totalItems = totalCollections + totalDocuments;
+        progress = ProgressManager.create(`backup-${databaseId}`, totalItems, {
+            title: `Backing up ${databaseId}`,
+        });
+        MessageFormatter.step(2, 3, `Processing ${totalCollections} collections and ${totalDocuments} documents`);
+        // Second pass: actual backup with progress tracking
+        lastCollectionId = "";
+        moreCollections = true;
         while (moreCollections) {
             const collectionResponse = await tryAwaitWithRetry(async () => await database.listCollections(databaseId, [
                 Query.limit(500),
                 ...(lastCollectionId ? [Query.cursorAfter(lastCollectionId)] : []),
             ]));
-            total += collectionResponse.collections.length;
             for (const { $id: collectionId, name: collectionName, } of collectionResponse.collections) {
                 try {
                     const collection = await tryAwaitWithRetry(async () => await database.getCollection(databaseId, collectionId));
-                    progress++;
                     data.collections.push(JSON.stringify(collection));
+                    progress?.increment(1, `Processing collection: ${collectionName}`);
                     let lastDocumentId = "";
                     let moreDocuments = true;
                     let collectionDocumentCount = 0;
@@ -183,7 +251,6 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
                                 ? [Query.cursorAfter(lastDocumentId)]
                                 : []),
                         ]));
-                        total += documentResponse.documents.length;
                         collectionDocumentCount += documentResponse.documents.length;
                         const documentPromises = documentResponse.documents.map(({ $id: documentId }) => database.getDocument(databaseId, collectionId, documentId));
                         const promiseBatches = splitIntoBatches(documentPromises);
@@ -191,31 +258,35 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
                         for (const batch of promiseBatches) {
                             const successfulDocuments = await retryFailedPromises(batch);
                             documentsPulled.push(...successfulDocuments);
+                            // Update progress for each batch
+                            progress?.increment(successfulDocuments.length, `Processing ${collectionName}: ${processedDocuments + successfulDocuments.length}/${totalDocuments} documents`);
+                            processedDocuments += successfulDocuments.length;
                         }
                         data.documents.push({
                             collectionId: collectionId,
                             data: JSON.stringify(documentsPulled),
                         });
-                        progress += documentsPulled.length;
-                        await logOperation(database, databaseId, {
-                            operationType: "backup",
-                            collectionId: collectionId,
-                            data: `Backing up, ${data.collections.length} collections so far`,
-                            progress: progress,
-                            total: total,
-                            error: "",
-                            status: "in_progress",
-                        }, backupOperation.$id);
+                        if (backupOperation) {
+                            await logOperation(database, databaseId, {
+                                operationType: "backup",
+                                collectionId: collectionId,
+                                data: `Backing up, ${data.collections.length} collections so far`,
+                                progress: processedDocuments,
+                                total: totalDocuments,
+                                error: "",
+                                status: "in_progress",
+                            }, backupOperation.$id, config.useMigrations);
+                        }
                         moreDocuments = documentResponse.documents.length === 500;
                         if (moreDocuments) {
                             lastDocumentId =
                                 documentResponse.documents[documentResponse.documents.length - 1].$id;
                         }
                     }
-                    console.log(`Collection ${collectionName} backed up with ${collectionDocumentCount} documents.`);
+                    MessageFormatter.success(`Collection ${collectionName} backed up with ${MessageFormatter.formatNumber(collectionDocumentCount)} documents`);
                 }
                 catch (error) {
-                    console.log(`Collection ${collectionName} must not exist, continuing...`);
+                    MessageFormatter.warning(`Collection ${collectionName} could not be backed up: ${error instanceof Error ? error.message : String(error)}`);
                     continue;
                 }
             }
@@ -225,32 +296,50 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
                     collectionResponse.collections[collectionResponse.collections.length - 1].$id;
             }
         }
+        MessageFormatter.step(3, 3, "Creating backup file");
         const bucket = await initOrGetDocumentStorage(storage, config, databaseId);
-        const inputFile = InputFile.fromPlainText(JSON.stringify(data), `${new Date().toISOString()}-${databaseId}.json`);
+        const backupData = JSON.stringify(data);
+        const backupSize = Buffer.byteLength(backupData, 'utf8');
+        const fileName = `${new Date().toISOString()}-${databaseId}.json`;
+        const inputFile = InputFile.fromPlainText(backupData, fileName);
         const fileCreated = await storage.createFile(bucket.$id, ulid(), inputFile);
-        await logOperation(database, databaseId, {
-            operationType: "backup",
-            collectionId: "",
-            data: fileCreated.$id,
-            progress: 100,
-            total: total,
-            error: "",
-            status: "completed",
-        }, backupOperation.$id);
-        console.log("---------------------------------");
-        console.log("Database Backup Complete");
-        console.log("---------------------------------");
+        progress?.stop();
+        if (backupOperation) {
+            await logOperation(database, databaseId, {
+                operationType: "backup",
+                collectionId: "",
+                data: fileCreated.$id,
+                progress: totalItems,
+                total: totalItems,
+                error: "",
+                status: "completed",
+            }, backupOperation.$id, config.useMigrations);
+        }
+        const duration = Date.now() - startTime;
+        MessageFormatter.operationSummary("Backup", {
+            database: databaseId,
+            collections: data.collections.length,
+            documents: processedDocuments,
+            fileSize: MessageFormatter.formatBytes(backupSize),
+            backupFile: fileName,
+            bucket: bucket.$id,
+        }, duration);
+        MessageFormatter.success(Messages.BACKUP_COMPLETED(databaseId, backupSize));
     }
     catch (error) {
-        console.error("Error during backup:", error);
-        await logOperation(database, databaseId, {
-            operationType: "backup",
-            collectionId: "",
-            data: "Backup failed",
-            progress: 0,
-            total: 100,
-            error: String(error),
-            status: "error",
-        }, backupOperation.$id);
+        progress?.fail(error instanceof Error ? error.message : String(error));
+        MessageFormatter.error("Backup failed", error instanceof Error ? error : new Error(String(error)));
+        if (backupOperation) {
+            await logOperation(database, databaseId, {
+                operationType: "backup",
+                collectionId: "",
+                data: "Backup failed",
+                progress: 0,
+                total: totalDocuments,
+                error: String(error),
+                status: "error",
+            }, backupOperation.$id, config.useMigrations);
+        }
+        throw error;
     }
 };

package/dist/storage/schemas.d.ts

@@ -9,31 +9,31 @@ export declare const BackupSchema: z.ZodObject<{
         collectionId: z.ZodString;
         data: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        collectionId: string;
         data: string;
-    }, {
         collectionId: string;
+    }, {
         data: string;
+        collectionId: string;
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
-    collections: string[];
     documents: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[];
     $id: string;
     $createdAt: string;
     $updatedAt: string;
+    collections: string[];
     database: string;
 }, {
-    collections: string[];
     $id: string;
     $createdAt: string;
     $updatedAt: string;
+    collections: string[];
     database: string;
     documents?: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[] | undefined;
 }>;
 export type Backup = z.infer<typeof BackupSchema>;
@@ -47,25 +47,25 @@ export declare const BackupCreateSchema: z.ZodObject<Omit<{
         collectionId: z.ZodString;
         data: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        collectionId: string;
         data: string;
-    }, {
         collectionId: string;
+    }, {
         data: string;
+        collectionId: string;
     }>, "many">>;
 }, "$id" | "$createdAt" | "$updatedAt">, "strip", z.ZodTypeAny, {
-    collections: string[];
     documents: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[];
+    collections: string[];
     database: string;
 }, {
     collections: string[];
     database: string;
     documents?: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[] | undefined;
 }>;
 export type BackupCreate = z.infer<typeof BackupCreateSchema>;
@@ -76,16 +76,16 @@ export declare const BatchSchema: z.ZodObject<{
     data: z.ZodString;
     processed: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    data: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    data: string;
     processed: boolean;
 }, {
+    data: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    data: string;
     processed?: boolean | undefined;
 }>;
 export type Batch = z.infer<typeof BatchSchema>;
@@ -116,11 +116,11 @@ export declare const OperationSchema: z.ZodObject<{
     error: z.ZodString;
     status: z.ZodDefault<z.ZodEnum<["pending", "ready", "in_progress", "completed", "error", "cancelled"]>>;
 }, "strip", z.ZodTypeAny, {
+    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
+    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    error: string;
     collectionId: string;
     operationType: string;
     progress: number;
@@ -128,10 +128,10 @@ export declare const OperationSchema: z.ZodObject<{
     data?: any;
     batches?: string[] | undefined;
 }, {
+    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    error: string;
     collectionId: string;
     operationType: string;
     progress: number;
@@ -198,6 +198,16 @@ export declare const getMigrationCollectionSchemas: () => {
                 xdefault?: number | null | undefined;
                 min?: number | undefined;
                 max?: number | undefined;
+            } | {
+                type: "double";
+                key: string;
+                description?: string | Record<string, string> | null | undefined;
+                required?: boolean | undefined;
+                array?: boolean | undefined;
+                error?: string | undefined;
+                xdefault?: number | null | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
             } | {
                 type: "float";
                 key: string;
@@ -351,6 +361,16 @@ export declare const getMigrationCollectionSchemas: () => {
             xdefault?: number | null | undefined;
             min?: number | undefined;
             max?: number | undefined;
+        } | {
+            type: "double";
+            key: string;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
         } | {
             type: "float";
             key: string;
@@ -453,6 +473,16 @@ export declare const getMigrationCollectionSchemas: () => {
                 xdefault?: number | null | undefined;
                 min?: number | undefined;
                 max?: number | undefined;
+            } | {
+                type: "double";
+                key: string;
+                description?: string | Record<string, string> | null | undefined;
+                required?: boolean | undefined;
+                array?: boolean | undefined;
+                error?: string | undefined;
+                xdefault?: number | null | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
             } | {
                 type: "float";
                 key: string;
@@ -606,6 +636,16 @@ export declare const getMigrationCollectionSchemas: () => {
             xdefault?: number | null | undefined;
             min?: number | undefined;
             max?: number | undefined;
+        } | {
+            type: "double";
+            key: string;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
         } | {
             type: "float";
             key: string;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type { ValidationRules } from "./migrations/validationRules.js";
+export type { ValidationRules } from "./utils/validationRules.js";
 export { type AuthUserCreate, AuthUserCreateSchema, type AuthUser, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./migrations/validationRules.js";
+export { validationRules } from "./utils/validationRules.js";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/types.js

@@ -1,3 +1,3 @@
 export { AuthUserCreateSchema, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./migrations/validationRules.js";
+export { validationRules } from "./utils/validationRules.js";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/users/methods.d.ts

@@ -0,0 +1,16 @@
+import type { AppwriteConfig } from "appwrite-utils";
+import { Databases, type Models } from "node-appwrite";
+import { type AuthUserCreate } from "../schemas/authUser.js";
+export declare class UsersController {
+    private config;
+    private users;
+    static userFields: string[];
+    constructor(config: AppwriteConfig, db: Databases);
+    wipeUsers(): Promise<void>;
+    getAllUsers(): Promise<Models.User<Models.Preferences>[]>;
+    createUsersAndReturn(items: AuthUserCreate[]): Promise<(Models.User<Models.Preferences> | undefined)[]>;
+    createUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences> | undefined>;
+    createAndCheckForUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences> | undefined>;
+    getUserIdByEmailOrPhone(email?: string, phone?: string): Promise<string | undefined>;
+    transferUsersBetweenDbsLocalToRemote: (endpoint: string, projectId: string, apiKey: string) => Promise<void>;
+}