appwrite-utils-cli 1.11.0 → 1.12.0

package/src/shared/backupMetadataSchema.ts

@@ -1,93 +0,0 @@
-import { z } from "zod";
-
-/**
- * Schema for centralized backup tracking table (_appwrite_backups)
- *
- * Tracks all backups created for databases, buckets, and comprehensive backups
- */
-
-export type BackupType = 'database' | 'bucket' | 'comprehensive';
-export type BackupFormat = 'json' | 'zip';
-export type BackupStatus = 'completed' | 'partial' | 'failed';
-export type RestorationStatus = 'completed' | 'partial' | 'failed' | 'not_restored';
-
-export const BACKUP_TYPES = ['database', 'bucket', 'comprehensive'] as const;
-export const BACKUP_FORMATS = ['json', 'zip'] as const;
-export const BACKUP_STATUSES = ['completed', 'partial', 'failed'] as const;
-export const RESTORATION_STATUSES = ['completed', 'partial', 'failed', 'not_restored'] as const;
-
-export const BackupTypeSchema = z.enum(['database', 'bucket', 'comprehensive']);
-export const BackupFormatSchema = z.enum(['json', 'zip']);
-export const BackupStatusSchema = z.enum(['completed', 'partial', 'failed']);
-export const RestorationStatusSchema = z.enum(['completed', 'partial', 'failed', 'not_restored']);
-
-export interface BackupMetadata {
-  $id: string;
-  $createdAt: string;
-  $updatedAt: string;
-
-  // Core backup info
-  backupType: BackupType;         // Type of backup: database, bucket, or comprehensive
-  backupId: string;               // File ID in storage bucket for the backup file
-  manifestFileId?: string;        // File ID for the manifest JSON file
-  format: BackupFormat;           // 'json' or 'zip'
-  sizeBytes: number;              // Total backup file size
-
-  // Resource identification (at least one must be present)
-  databaseId?: string;            // Database ID (for database backups)
-  bucketId?: string;              // Bucket ID (for bucket backups)
-  comprehensiveBackupId?: string; // Parent comprehensive backup ID
-
-  // Database-specific metrics
-  collections?: number;           // Number of collections backed up
-  documents?: number;             // Number of documents backed up
-
-  // Bucket-specific metrics
-  fileCount?: number;             // Number of files backed up (for bucket backups)
-
-  // Status tracking
-  status: BackupStatus;           // 'completed', 'partial', or 'failed'
-  error?: string;                 // Error message if failed or partial
-
-  // Restoration tracking
-  restoredAt?: string;            // ISO timestamp of restoration
-  restorationStatus: RestorationStatus; // Restoration status
-  restorationError?: string;      // Error message if restoration failed
-}
-
-export const BackupMetadataSchema = z.object({
-  $id: z.string(),
-  $createdAt: z.string(),
-  $updatedAt: z.string(),
-
-  // Core backup info
-  backupType: BackupTypeSchema,
-  backupId: z.string(),
-  manifestFileId: z.string().optional(),
-  format: BackupFormatSchema,
-  sizeBytes: z.number(),
-
-  // Resource identification
-  databaseId: z.string().optional(),
-  bucketId: z.string().optional(),
-  comprehensiveBackupId: z.string().optional(),
-
-  // Database-specific metrics
-  collections: z.number().optional(),
-  documents: z.number().optional(),
-
-  // Bucket-specific metrics
-  fileCount: z.number().optional(),
-
-  // Status tracking
-  status: BackupStatusSchema,
-  error: z.string().optional(),
-
-  // Restoration tracking
-  restoredAt: z.string().optional(),
-  restorationStatus: RestorationStatusSchema.default('not_restored'),
-  restorationError: z.string().optional()
-});
-
-export const BACKUP_TABLE_ID = "appwrite_backups";
-export const BACKUP_TABLE_NAME = "Backup Tracking";

package/src/shared/backupTracking.ts

@@ -1,211 +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 {
-  BACKUP_TABLE_ID,
-  BACKUP_TABLE_NAME,
-  type BackupMetadata,
-  BackupMetadataSchema
-} from "./backupMetadataSchema.js";
-
-/**
- * Checks if backup tracking table exists in database
- */
-async function tableExists(
-  db: DatabaseAdapter,
-  databaseId: string
-): Promise<boolean> {
-  try {
-    await db.getTable({ databaseId, tableId: BACKUP_TABLE_ID });
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-/**
- * Creates the backup tracking table in the specified database
- */
-export async function createBackupTrackingTable(
-  db: DatabaseAdapter,
-  databaseId: string
-): Promise<void> {
-  // Check if table already exists
-  const exists = await tableExists(db, databaseId);
-  if (exists) {
-    logger.debug("Backup tracking table already exists", {
-      databaseId,
-      tableId: BACKUP_TABLE_ID
-    });
-    return;
-  }
-
-  logger.info("Creating backup tracking table", {
-    databaseId,
-    tableId: BACKUP_TABLE_ID
-  });
-
-  // Create table
-  await tryAwaitWithRetry(async () => {
-    await db.createTable({
-      databaseId,
-      id: BACKUP_TABLE_ID,
-      name: BACKUP_TABLE_NAME
-    });
-  });
-
-  // Create attributes
-  const attributes = [
-    {
-      key: "backupId",
-      type: "string" as const,
-      size: 50,
-      required: true
-    },
-    {
-      key: "databaseId",
-      type: "string" as const,
-      size: 50,
-      required: true
-    },
-    {
-      key: "sizeBytes",
-      type: "integer" as const,
-      required: true
-    },
-    {
-      key: "collections",
-      type: "integer" as const,
-      required: true
-    },
-    {
-      key: "documents",
-      type: "integer" as const,
-      required: true
-    },
-    {
-      key: "format",
-      type: "enum" as const,
-      elements: ["json", "zip"],
-      required: true
-    },
-    {
-      key: "status",
-      type: "enum" as const,
-      elements: ["completed", "failed"],
-      required: true
-    },
-    {
-      key: "error",
-      type: "string" as const,
-      size: 10000,
-      required: false
-    }
-  ];
-
-  for (const attr of attributes) {
-    await tryAwaitWithRetry(async () => {
-      await db.createAttribute({
-        databaseId,
-        tableId: BACKUP_TABLE_ID,
-        ...attr
-      });
-    });
-  }
-
-  logger.info("Backup tracking table created successfully", {
-    databaseId,
-    tableId: BACKUP_TABLE_ID
-  });
-}
-
-/**
- * Records backup metadata in the tracking table
- */
-export async function recordBackup(
-  db: DatabaseAdapter,
-  databaseId: string,
-  metadata: Omit<BackupMetadata, '$id' | '$createdAt' | '$updatedAt'>
-): Promise<BackupMetadata> {
-  // Ensure tracking table exists
-  await createBackupTrackingTable(db, databaseId);
-
-  // Create backup record
-  const result = await db.createRow({
-    databaseId,
-    tableId: BACKUP_TABLE_ID,
-    id: ID.unique(),
-    data: {
-      backupId: metadata.backupId,
-      databaseId: metadata.databaseId,
-      sizeBytes: metadata.sizeBytes,
-      collections: metadata.collections,
-      documents: metadata.documents,
-      format: metadata.format,
-      status: metadata.status,
-      error: metadata.error
-    }
-  });
-
-  logger.info("Recorded backup metadata", {
-    backupId: metadata.backupId,
-    databaseId: metadata.databaseId,
-    format: metadata.format
-  });
-
-  return result.data as BackupMetadata;
-}
-
-/**
- * Lists all backups for a database, sorted by creation date (newest first)
- */
-export async function listBackups(
-  db: DatabaseAdapter,
-  databaseId: string
-): Promise<BackupMetadata[]> {
-  try {
-    const result = await db.listRows({
-      databaseId,
-      tableId: BACKUP_TABLE_ID,
-      queries: [
-        Query.orderDesc("$createdAt"),
-        Query.limit(100) // Limit to last 100 backups
-      ]
-    });
-
-    return (result.rows || []) as BackupMetadata[];
-  } catch (error) {
-    // Table might not exist yet
-    logger.debug("No backup tracking table found", { databaseId });
-    return [];
-  }
-}
-
-/**
- * Gets the most recent backup for a database
- */
-export async function getLastBackup(
-  db: DatabaseAdapter,
-  databaseId: string
-): Promise<BackupMetadata | null> {
-  try {
-    const result = await db.listRows({
-      databaseId,
-      tableId: BACKUP_TABLE_ID,
-      queries: [
-        Query.orderDesc("$createdAt"),
-        Query.limit(1)
-      ]
-    });
-
-    if (result.rows && result.rows.length > 0) {
-      return result.rows[0] as BackupMetadata;
-    }
-
-    return null;
-  } catch (error) {
-    logger.debug("No backup found or table doesn't exist", { databaseId });
-    return null;
-  }
-}

package/src/shared/confirmationDialogs.ts

@@ -1,327 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-import { MessageFormatter } from 'appwrite-utils-helpers';
-
-export interface DestructiveOperationOptions {
-  operation: string;
-  targets: string[];
-  consequences?: string[];
-  requireExplicitConfirmation?: boolean;
-  confirmationText?: string;
-  skipConfirmation?: boolean;
-}
-
-export interface BackupPromptOptions {
-  operation: string;
-  targets: string[];
-  recommendBackup?: boolean;
-  backupMessage?: string;
-}
-
-export class ConfirmationDialogs {
-  /**
-   * Shows a confirmation dialog for destructive operations
-   */
-  static async confirmDestructiveOperation(options: DestructiveOperationOptions): Promise<boolean> {
-    if (options.skipConfirmation) {
-      return true;
-    }
-
-    MessageFormatter.warning(`You are about to perform a destructive operation:`, { skipLogging: true });
-    MessageFormatter.error(`Operation: ${options.operation}`, undefined, { skipLogging: true });
-    MessageFormatter.warning(`Targets: ${options.targets.join(", ")}`, { skipLogging: true });
-
-    if (options.consequences && options.consequences.length > 0) {
-      MessageFormatter.error("This will:", undefined, { skipLogging: true });
-      options.consequences.forEach(consequence => {
-        MessageFormatter.error(`  • ${consequence}`, undefined, { skipLogging: true });
-      });
-    }
-
-    MessageFormatter.error("⚠️  THIS ACTION CANNOT BE UNDONE!", undefined, { skipLogging: true });
-
-    if (options.requireExplicitConfirmation && options.confirmationText) {
-      const { confirmation } = await inquirer.prompt([{
-        type: 'input',
-        name: 'confirmation',
-        message: chalk.red(`Type "${options.confirmationText}" to confirm:`),
-        validate: (input: string) => {
-          return input === options.confirmationText || 
-            chalk.red(`Please type exactly: ${options.confirmationText}`);
-        }
-      }]);
-      
-      return confirmation === options.confirmationText;
-    } else {
-      const { confirmed } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'confirmed',
-        message: chalk.red('Are you absolutely sure you want to continue?'),
-        default: false
-      }]);
-      
-      return confirmed;
-    }
-  }
-
-  /**
-   * Prompts user about creating a backup before a destructive operation
-   */
-  static async promptForBackup(options: BackupPromptOptions): Promise<'yes' | 'no' | 'skip'> {
-    const message = options.backupMessage ||
-      `Create a backup before performing ${options.operation} on: ${options.targets.join(", ")}?`;
-
-    MessageFormatter.info("🛡️  Backup Recommendation", { skipLogging: true });
-    if (options.recommendBackup !== false) {
-      MessageFormatter.warning("It's strongly recommended to create a backup before proceeding.", { skipLogging: true });
-    }
-    
-    const { choice } = await inquirer.prompt([{
-      type: 'list',
-      name: 'choice',
-      message,
-      choices: [
-        { name: '🛡️  Yes, create backup first', value: 'yes' },
-        { name: '⚠️  No, proceed without backup', value: 'no' },
-        { name: '❌ Cancel operation', value: 'skip' }
-      ],
-      default: 'yes'
-    }]);
-
-    return choice;
-  }
-
-  /**
-   * Shows a final confirmation before proceeding with an operation
-   */
-  static async finalConfirmation(operation: string, details?: string[]): Promise<boolean> {
-    MessageFormatter.success(`Ready to perform: ${operation}`, { skipLogging: true });
-
-    if (details && details.length > 0) {
-      MessageFormatter.debug("Details:", undefined, { skipLogging: true });
-      details.forEach(detail => {
-        MessageFormatter.debug(`  • ${detail}`, undefined, { skipLogging: true });
-      });
-    }
-
-    const { proceed } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'proceed',
-      message: 'Proceed with this operation?',
-      default: true
-    }]);
-
-    return proceed;
-  }
-
-  /**
-   * Specialized confirmation for database wiping
-   */
-  static async confirmDatabaseWipe(databaseNames: string[], options: {
-    includeStorage?: boolean;
-    includeUsers?: boolean;
-    skipConfirmation?: boolean;
-  } = {}): Promise<boolean> {
-    const consequences = [
-      "Delete all documents in the specified databases",
-      "Remove all collections and their data",
-    ];
-
-    if (options.includeStorage) {
-      consequences.push("Delete all files in associated storage buckets");
-    }
-
-    if (options.includeUsers) {
-      consequences.push("Delete all user accounts");
-    }
-
-    return this.confirmDestructiveOperation({
-      operation: "Database Wipe",
-      targets: databaseNames,
-      consequences,
-      requireExplicitConfirmation: true,
-      confirmationText: "DELETE ALL DATA",
-      skipConfirmation: options.skipConfirmation,
-    });
-  }
-
-  /**
-   * Specialized confirmation for collection wiping
-   */
-  static async confirmCollectionWipe(
-    databaseName: string, 
-    collectionNames: string[],
-    options: { skipConfirmation?: boolean } = {}
-  ): Promise<boolean> {
-    return this.confirmDestructiveOperation({
-      operation: "Collection Wipe",
-      targets: collectionNames.map(name => `${databaseName}.${name}`),
-      consequences: [
-        "Delete all documents in the specified collections",
-        "Keep the collection structure intact",
-      ],
-      requireExplicitConfirmation: collectionNames.length > 5,
-      confirmationText: "DELETE DOCUMENTS",
-      skipConfirmation: options.skipConfirmation,
-    });
-  }
-
-  /**
-   * Specialized confirmation for function deployment
-   */
-  static async confirmFunctionDeployment(
-    functionNames: string[],
-    options: { 
-      isProduction?: boolean; 
-      hasBreakingChanges?: boolean;
-      skipConfirmation?: boolean;
-    } = {}
-  ): Promise<boolean> {
-    if (options.skipConfirmation) {
-      return true;
-    }
-
-    const consequences = ["Replace existing function code"];
-    
-    if (options.isProduction) {
-      consequences.push("Affect production environment");
-    }
-
-    if (options.hasBreakingChanges) {
-      consequences.push("Potentially break existing integrations");
-    }
-
-    return this.confirmDestructiveOperation({
-      operation: "Function Deployment",
-      targets: functionNames,
-      consequences: consequences.length > 1 ? consequences : undefined,
-      requireExplicitConfirmation: options.isProduction || options.hasBreakingChanges,
-      confirmationText: options.isProduction ? "DEPLOY TO PRODUCTION" : "DEPLOY",
-    });
-  }
-
-  /**
-   * Shows operation summary and asks for final confirmation
-   */
-  static async showOperationSummary(
-    title: string,
-    summary: Record<string, string | number | string[]>,
-    options: { 
-      confirmationRequired?: boolean;
-      warningMessage?: string;
-    } = {}
-  ): Promise<boolean> {
-    MessageFormatter.section(`${title} Summary`);
-    
-    Object.entries(summary).forEach(([key, value]) => {
-      const formattedKey = key.replace(/([A-Z])/g, ' $1').replace(/^./, str => str.toUpperCase());
-
-      if (Array.isArray(value)) {
-        MessageFormatter.info(`● ${formattedKey}:`, { skipLogging: true });
-        value.forEach(item => {
-          MessageFormatter.debug(`  • ${item}`, undefined, { skipLogging: true });
-        });
-      } else {
-        MessageFormatter.info(`● ${formattedKey}: ${String(value)}`, { skipLogging: true });
-      }
-    });
-
-    if (options.warningMessage) {
-      MessageFormatter.warning(`⚠️  ${options.warningMessage}`, { skipLogging: true });
-    }
-
-    if (options.confirmationRequired !== false) {
-      const { confirmed } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'confirmed',
-        message: 'Continue with this operation?',
-        default: true
-      }]);
-      
-      return confirmed;
-    }
-
-    return true;
-  }
-
-  /**
-   * Interactive selection with confirmation
-   */
-  static async selectWithConfirmation<T>(
-    items: T[],
-    options: {
-      message: string;
-      displayProperty?: keyof T;
-      multiSelect?: boolean;
-      confirmMessage?: string;
-      validator?: (selection: T[]) => string | true;
-    }
-  ): Promise<T[]> {
-    const choices = items.map((item, index) => ({
-      name: options.displayProperty ? String(item[options.displayProperty]) : String(item),
-      value: item,
-    }));
-
-    const prompt = options.multiSelect ? 'checkbox' : 'list';
-    const { selection } = await inquirer.prompt([{
-      type: prompt,
-      name: 'selection',
-      message: options.message,
-      choices,
-      validate: options.validator ? (input: T[]) => {
-        const result = options.validator!(Array.isArray(input) ? input : [input]);
-        return result;
-      } : undefined,
-    }]);
-
-    const selectedItems = Array.isArray(selection) ? selection : [selection];
-    
-    if (options.confirmMessage) {
-      const confirmMessage = options.confirmMessage.replace(
-        '{count}', 
-        selectedItems.length.toString()
-      );
-      
-      const { confirmed } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'confirmed',
-        message: confirmMessage,
-        default: true
-      }]);
-
-      if (!confirmed) {
-        return [];
-      }
-    }
-
-    return selectedItems;
-  }
-
-  /**
-   * Confirms overwriting an existing file or directory
-   */
-  static async confirmOverwrite(target: string): Promise<boolean> {
-    const { confirmed } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'confirmed',
-      message: chalk.yellow(`${target} already exists. Overwrite?`),
-      default: false
-    }]);
-    
-    return confirmed;
-  }
-
-  /**
-   * Confirms removal of a file
-   */
-  static async confirmRemoval(target: string): Promise<boolean> {
-    const { confirmed } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'confirmed',
-      message: chalk.red(target),
-      default: false
-    }]);
-    
-    return confirmed;
-  }
-}