appwrite-utils-cli 1.11.0 → 1.12.0

package/src/shared/operationsTable.ts

@@ -1,338 +0,0 @@
-import type { DatabaseAdapter } from "appwrite-utils-helpers";
-import { logger } from 'appwrite-utils-helpers';
-import { tryAwaitWithRetry } from "appwrite-utils-helpers";
-import { Query, ID } from "node-appwrite";
-import {
-	OPERATIONS_TABLE_ID,
-	OPERATIONS_TABLE_NAME,
-	type OperationRecord,
-	type OperationStatus,
-	OperationRecordSchema,
-} from "./operationsTableSchema.js";
-
-/**
- * Operations Table Manager
- *
- * Manages dynamic operations tracking tables in each database.
- * Creates _appwrite_operations table on-demand for tracking imports, exports, transfers, etc.
- */
-
-/**
- * Checks if operations table exists in database
- */
-async function tableExists(
-	db: DatabaseAdapter,
-	databaseId: string,
-): Promise<boolean> {
-	try {
-		await db.getTable({ databaseId, tableId: OPERATIONS_TABLE_ID });
-		return true;
-	} catch (error) {
-		return false;
-	}
-}
-
-/**
- * Creates the operations tracking table in the specified database
- * Table is created with underscore prefix to indicate it's a system table
- */
-export async function createOperationsTable(
-	db: DatabaseAdapter,
-	databaseId: string,
-): Promise<void> {
-	const exists = await tableExists(db, databaseId);
-
-	if (!exists) {
-		logger.info("Creating operations tracking table", {
-			databaseId,
-			tableId: OPERATIONS_TABLE_ID,
-		});
-
-		await tryAwaitWithRetry(async () => {
-			await db.createTable({
-				databaseId,
-				id: OPERATIONS_TABLE_ID,
-				name: OPERATIONS_TABLE_NAME,
-			});
-		});
-	}
-
-	// Always ensure attributes exist (handles partial creation from previous runs)
-	const attributes = [
-		{
-			key: "operationType",
-			type: "string",
-			size: 255,
-			required: true,
-		},
-		{
-			key: "targetTable",
-			type: "string",
-			size: 255,
-			required: false,
-		},
-		{
-			key: "status",
-			type: "enum",
-			elements: ["pending", "in_progress", "completed", "failed", "cancelled"],
-			required: false,
-			default: "pending",
-		},
-		{
-			key: "progress",
-			type: "integer",
-			required: false,
-			default: 0,
-		},
-		{
-			key: "total",
-			type: "integer",
-			required: false,
-			default: 0,
-		},
-		{
-			key: "data",
-			type: "string",
-			size: 1048576, // 1MB for serialized data
-			required: false,
-		},
-		{
-			key: "error",
-			type: "string",
-			size: 65535,
-			required: false,
-		},
-	];
-
-	for (const attr of attributes) {
-		try {
-			await db.createAttribute({
-				databaseId,
-				tableId: OPERATIONS_TABLE_ID,
-				...attr,
-			});
-		} catch (error) {
-			// Attribute may already exist from a previous run — that's fine, skip it
-			const msg = error instanceof Error ? error.message : String(error);
-			if (msg.includes("already exists") || msg.includes("column_already_exists")) {
-				continue;
-			}
-			throw error;
-		}
-	}
-
-	logger.info("Operations tracking table ready", {
-		databaseId,
-		tableId: OPERATIONS_TABLE_ID,
-		attributes: attributes.length,
-	});
-}
-
-/**
- * Finds an existing operation or creates a new one
- * Useful for resuming interrupted operations
- */
-export async function findOrCreateOperation(
-	db: DatabaseAdapter,
-	databaseId: string,
-	operationType: string,
-	params?: Partial<OperationRecord>,
-): Promise<OperationRecord> {
-	// Ensure operations table exists
-	await createOperationsTable(db, databaseId);
-
-	// Try to find existing pending operation
-	try {
-		const queries = [
-			Query.equal("operationType", operationType),
-			Query.equal("status", "pending"),
-		];
-
-		if (params?.targetTable) {
-			queries.push(Query.equal("targetTable", params.targetTable));
-		}
-
-		const response = await db.listRows({
-			databaseId,
-			tableId: OPERATIONS_TABLE_ID,
-			queries,
-		});
-
-		if (response.rows && response.rows.length > 0) {
-			logger.debug("Found existing operation", {
-				operationId: response.rows[0].$id,
-				operationType,
-			});
-			return response.rows[0] as OperationRecord;
-		}
-	} catch (error) {
-		logger.debug("No existing operation found, creating new one", {
-			operationType,
-			error: error instanceof Error ? error.message : String(error),
-		});
-	}
-
-	// Create new operation
-	const newOperation = {
-		operationType,
-		targetTable: params?.targetTable,
-		status: "pending" as OperationStatus,
-		progress: params?.progress ?? 0,
-		total: params?.total ?? 0,
-		data: params?.data ? JSON.stringify(params.data) : undefined,
-		error: params?.error,
-	};
-
-	const result = await db.createRow({
-		databaseId,
-		tableId: OPERATIONS_TABLE_ID,
-		id: ID.unique(),
-		data: newOperation,
-	});
-
-	logger.info("Created new operation", {
-		operationId: result.data?.$id,
-		operationType,
-	});
-
-	return result.data as OperationRecord;
-}
-
-/**
- * Updates an existing operation record
- */
-export async function updateOperation(
-	db: DatabaseAdapter,
-	databaseId: string,
-	operationId: string,
-	updates: Partial<OperationRecord>,
-): Promise<OperationRecord> {
-	// Prepare update data (exclude system fields like $id, $createdAt, $updatedAt)
-	const updateData: Record<string, any> = {};
-
-	if (updates.operationType !== undefined)
-		updateData.operationType = updates.operationType;
-	if (updates.targetTable !== undefined)
-		updateData.targetTable = updates.targetTable;
-	if (updates.status !== undefined) updateData.status = updates.status;
-	if (updates.progress !== undefined) updateData.progress = updates.progress;
-	if (updates.total !== undefined) updateData.total = updates.total;
-	if (updates.error !== undefined) updateData.error = updates.error;
-	if (updates.data !== undefined) {
-		updateData.data =
-			typeof updates.data === "string"
-				? updates.data
-				: JSON.stringify(updates.data);
-	}
-
-	try {
-		const result = await db.updateRow({
-			databaseId,
-			tableId: OPERATIONS_TABLE_ID,
-			id: operationId,
-			data: updateData,
-		});
-
-		logger.debug("Updated operation", {
-			operationId,
-			updates: Object.keys(updateData),
-		});
-
-		return result.data as OperationRecord;
-	} catch (error) {
-		logger.error("Failed to update operation", {
-			operationId,
-			error: error instanceof Error ? error.message : String(error),
-		});
-		throw error;
-	}
-}
-
-/**
- * Gets a single operation by ID
- */
-export async function getOperation(
-	db: DatabaseAdapter,
-	databaseId: string,
-	operationId: string,
-): Promise<OperationRecord | null> {
-	try {
-		const result = await db.getRow({
-			databaseId,
-			tableId: OPERATIONS_TABLE_ID,
-			id: operationId,
-		});
-
-		return result.data as OperationRecord;
-	} catch (error) {
-		logger.debug("Operation not found", {
-			operationId,
-			error: error instanceof Error ? error.message : String(error),
-		});
-		return null;
-	}
-}
-
-/**
- * Cleans up old completed operations
- * @param olderThan - Optional date, defaults to operations older than 7 days
- * @returns Number of operations deleted
- */
-export async function cleanupOperations(
-	db: DatabaseAdapter,
-	databaseId: string,
-	olderThan?: Date,
-): Promise<number> {
-	const cutoffDate =
-		olderThan || new Date(Date.now() - 7 * 24 * 60 * 60 * 1000); // 7 days ago
-	const cutoffIso = cutoffDate.toISOString();
-
-	try {
-		// Query for completed operations older than cutoff
-		const response = await db.listRows({
-			databaseId,
-			tableId: OPERATIONS_TABLE_ID,
-			queries: [
-				Query.equal("status", ["completed", "failed", "cancelled"]),
-				Query.lessThan("$createdAt", cutoffIso),
-			],
-		});
-
-		if (!response.rows || response.rows.length === 0) {
-			logger.debug("No old operations to clean up", { databaseId });
-			return 0;
-		}
-
-		// Delete in batches
-		let deletedCount = 0;
-		for (const operation of response.rows) {
-			try {
-				await db.deleteRow({
-					databaseId,
-					tableId: OPERATIONS_TABLE_ID,
-					id: operation.$id,
-				});
-				deletedCount++;
-			} catch (error) {
-				logger.warn("Failed to delete operation", {
-					operationId: operation.$id,
-					error: error instanceof Error ? error.message : String(error),
-				});
-			}
-		}
-
-		logger.info("Cleaned up old operations", {
-			databaseId,
-			deletedCount,
-			cutoffDate: cutoffIso,
-		});
-
-		return deletedCount;
-	} catch (error) {
-		logger.error("Failed to cleanup operations", {
-			databaseId,
-			error: error instanceof Error ? error.message : String(error),
-		});
-		return 0;
-	}
-}

package/src/shared/operationsTableSchema.ts

@@ -1,60 +0,0 @@
-/**
- * Schema for operation tracking table (_appwrite_operations)
- *
- * This table is created dynamically in each database to track long-running operations
- * like imports, exports, transfers, and backups.
- */
-
-import { z } from "zod";
-
-export interface OperationRecord {
-  $id: string;
-  $createdAt: string;
-  $updatedAt: string;
-  operationType: string;        // 'import', 'export', 'transfer', 'backup', etc.
-  targetTable?: string;    // Optional: which collection is being operated on
-  status: OperationStatus;
-  progress: number;             // Current progress count
-  total: number;                // Total items to process
-  data?: any;                   // Optional: serialized operation data
-  error?: string;               // Optional: error message if failed
-}
-
-export type OperationStatus =
-  | 'pending'
-  | 'in_progress'
-  | 'completed'
-  | 'failed'
-  | 'cancelled';
-
-export const OPERATION_STATUSES = [
-  'pending',
-  'in_progress',
-  'completed',
-  'failed',
-  'cancelled'
-] as const;
-
-export const OperationStatusSchema = z.enum([
-  'pending',
-  'in_progress',
-  'completed',
-  'failed',
-  'cancelled'
-]);
-
-export const OperationRecordSchema = z.object({
-  $id: z.string(),
-  $createdAt: z.string(),
-  $updatedAt: z.string(),
-  operationType: z.string(),
-  targetTable: z.string().optional(),
-  status: OperationStatusSchema,
-  progress: z.number(),
-  total: z.number(),
-  data: z.any().optional(),
-  error: z.string().optional()
-});
-
-export const OPERATIONS_TABLE_ID = "appwrite_operations";
-export const OPERATIONS_TABLE_NAME = "Operations Tracking";

package/src/shared/progressManager.ts

@@ -1,278 +0,0 @@
-import cliProgress from "cli-progress";
-import chalk from "chalk";
-import { MessageFormatter } from 'appwrite-utils-helpers';
-
-export interface ProgressOptions {
-  title?: string;
-  showETA?: boolean;
-  showSpeed?: boolean;
-  showPercentage?: boolean;
-  width?: number;
-  format?: string;
-}
-
-export class ProgressManager {
-  private static instances = new Map<string, ProgressManager>();
-  private bar: cliProgress.SingleBar;
-  private startTime: number;
-  private totalItems: number;
-  private completed: number = 0;
-  private id: string;
-  private title: string;
-
-  private constructor(id: string, total: number, options: ProgressOptions = {}) {
-    this.id = id;
-    this.totalItems = total;
-    this.startTime = Date.now();
-    this.title = options.title || "Processing";
-
-    const format = options.format || 
-      `${chalk.cyan(this.title)} ${chalk.yellow("[{bar}]")} {percentage}% | {value}/{total} | ETA: {eta}s | Speed: {speed}/s`;
-
-    this.bar = new cliProgress.SingleBar({
-      format,
-      barCompleteChar: '█',
-      barIncompleteChar: '░',
-      hideCursor: true,
-      clearOnComplete: false,
-      stopOnComplete: true,
-      ...options,
-    }, cliProgress.Presets.shades_classic);
-
-    this.bar.start(total, 0);
-  }
-
-  static create(id: string, total: number, options: ProgressOptions = {}): ProgressManager {
-    if (ProgressManager.instances.has(id)) {
-      const existing = ProgressManager.instances.get(id)!;
-      existing.stop();
-    }
-
-    const instance = new ProgressManager(id, total, options);
-    ProgressManager.instances.set(id, instance);
-    return instance;
-  }
-
-  static get(id: string): ProgressManager | undefined {
-    return ProgressManager.instances.get(id);
-  }
-
-  update(current: number, detail?: string) {
-    this.completed = current;
-    
-    // Calculate speed
-    const elapsed = (Date.now() - this.startTime) / 1000;
-    const speed = elapsed > 0 ? Math.round(current / elapsed) : 0;
-
-    this.bar.update(current, {
-      speed,
-      detail: detail || '',
-    });
-
-    if (detail) {
-      // Update the payload for custom formatting
-      this.bar.update(current, { detail });
-    }
-  }
-
-  increment(amount: number = 1, detail?: string) {
-    this.update(this.completed + amount, detail);
-  }
-
-  setTotal(total: number) {
-    this.totalItems = total;
-    this.bar.setTotal(total);
-  }
-
-  stop(showSummary: boolean = true) {
-    this.bar.stop();
-    
-    if (showSummary) {
-      const duration = Date.now() - this.startTime;
-      const rate = this.completed / (duration / 1000);
-      
-      MessageFormatter.success(
-        `${this.title} completed`,
-        { 
-          prefix: `${this.completed}/${this.totalItems} items in ${MessageFormatter.formatDuration(duration)} (${rate.toFixed(1)}/s)` 
-        }
-      );
-    }
-
-    ProgressManager.instances.delete(this.id);
-  }
-
-  fail(error: string) {
-    this.bar.stop();
-    MessageFormatter.error(`${this.title} failed: ${error}`);
-    ProgressManager.instances.delete(this.id);
-  }
-
-  getStats() {
-    const duration = Date.now() - this.startTime;
-    const rate = this.completed / (duration / 1000);
-    
-    return {
-      completed: this.completed,
-      total: this.totalItems,
-      percentage: (this.completed / this.totalItems) * 100,
-      duration,
-      rate,
-      remaining: this.totalItems - this.completed,
-      eta: this.completed > 0 ? ((this.totalItems - this.completed) / rate) * 1000 : 0,
-    };
-  }
-
-  static stopAll() {
-    for (const [id, instance] of ProgressManager.instances) {
-      instance.stop(false);
-    }
-    ProgressManager.instances.clear();
-  }
-}
-
-export class MultiProgressManager {
-  private multiBar: cliProgress.MultiBar;
-  private bars = new Map<string, cliProgress.SingleBar>();
-  private startTime: number;
-
-  constructor(options: ProgressOptions = {}) {
-    this.startTime = Date.now();
-    
-    this.multiBar = new cliProgress.MultiBar({
-      clearOnComplete: false,
-      hideCursor: true,
-      format: options.format || `${chalk.cyan("{title}")} ${chalk.yellow("[{bar}]")} {percentage}% | {value}/{total} | {detail}`,
-      barCompleteChar: '█',
-      barIncompleteChar: '░',
-    }, cliProgress.Presets.shades_classic);
-  }
-
-  addTask(id: string, total: number, title: string): void {
-    const bar = this.multiBar.create(total, 0, {
-      title: title.padEnd(20),
-      detail: '',
-    });
-    this.bars.set(id, bar);
-  }
-
-  updateTask(id: string, current: number, detail?: string): void {
-    const bar = this.bars.get(id);
-    if (bar) {
-      bar.update(current, {
-        detail: detail || '',
-      });
-    }
-  }
-
-  incrementTask(id: string, amount: number = 1, detail?: string): void {
-    const bar = this.bars.get(id);
-    if (bar) {
-      const currentValue = bar.getProgress() * bar.getTotal();
-      this.updateTask(id, currentValue + amount, detail);
-    }
-  }
-
-  completeTask(id: string): void {
-    const bar = this.bars.get(id);
-    if (bar) {
-      bar.update(bar.getTotal());
-    }
-  }
-
-  failTask(id: string, error: string): void {
-    const bar = this.bars.get(id);
-    if (bar) {
-      bar.update(bar.getProgress() * bar.getTotal(), {
-        detail: chalk.red(`Failed: ${error}`),
-      });
-    }
-  }
-
-  stop(showSummary: boolean = true): void {
-    this.multiBar.stop();
-    
-    if (showSummary) {
-      const duration = Date.now() - this.startTime;
-      MessageFormatter.success(
-        `All tasks completed in ${MessageFormatter.formatDuration(duration)}`
-      );
-    }
-  }
-
-  getTaskStats(id: string) {
-    const bar = this.bars.get(id);
-    if (!bar) return null;
-
-    const progress = bar.getProgress();
-    const total = bar.getTotal();
-    const completed = Math.floor(progress * total);
-
-    return {
-      completed,
-      total,
-      percentage: progress * 100,
-      remaining: total - completed,
-    };
-  }
-
-  getAllStats() {
-    const stats = new Map<string, any>();
-    for (const [id, bar] of this.bars) {
-      stats.set(id, this.getTaskStats(id));
-    }
-    return stats;
-  }
-}
-
-// Utility functions for common progress scenarios
-export const ProgressUtils = {
-  async withProgress<T>(
-    id: string,
-    total: number,
-    title: string,
-    operation: (progress: ProgressManager) => Promise<T>
-  ): Promise<T> {
-    const progress = ProgressManager.create(id, total, { title });
-    try {
-      const result = await operation(progress);
-      progress.stop();
-      return result;
-    } catch (error) {
-      progress.fail(error instanceof Error ? error.message : String(error));
-      throw error;
-    }
-  },
-
-  async processArrayWithProgress<T, R>(
-    items: T[],
-    processor: (item: T, index: number) => Promise<R>,
-    options: { title?: string; batchSize?: number; showDetail?: boolean } = {}
-  ): Promise<R[]> {
-    const { title = "Processing items", batchSize = 1, showDetail = true } = options;
-    const progress = ProgressManager.create(`process-${Date.now()}`, items.length, { title });
-    
-    const results: R[] = [];
-    
-    try {
-      for (let i = 0; i < items.length; i += batchSize) {
-        const batch = items.slice(i, i + batchSize);
-        const batchResults = await Promise.all(
-          batch.map(async (item, batchIndex) => {
-            const result = await processor(item, i + batchIndex);
-            const detail = showDetail ? `Item ${i + batchIndex + 1}: ${String(item).slice(0, 30)}...` : undefined;
-            progress.update(i + batchIndex + 1, detail);
-            return result;
-          })
-        );
-        results.push(...batchResults);
-      }
-      
-      progress.stop();
-      return results;
-    } catch (error) {
-      progress.fail(error instanceof Error ? error.message : String(error));
-      throw error;
-    }
-  },
-};