@njdamstra/appwrite-utils-cli 1.8.9

package/dist/shared/selectionDialogs.d.ts

@@ -0,0 +1,214 @@
+import type { Models } from "node-appwrite";
+/**
+ * Interface for sync selection summary
+ */
+export interface SyncSelectionSummary {
+    databases: DatabaseSelection[];
+    buckets: BucketSelection[];
+    totalDatabases: number;
+    totalTables: number;
+    totalBuckets: number;
+    newItems: {
+        databases: number;
+        tables: number;
+        buckets: number;
+    };
+    existingItems: {
+        databases: number;
+        tables: number;
+        buckets: number;
+    };
+}
+/**
+ * Database selection with associated tables
+ */
+export interface DatabaseSelection {
+    databaseId: string;
+    databaseName: string;
+    tableIds: string[];
+    tableNames: string[];
+    isNew: boolean;
+}
+/**
+ * Bucket selection with associated database
+ */
+export interface BucketSelection {
+    bucketId: string;
+    bucketName: string;
+    databaseId?: string;
+    databaseName?: string;
+    isNew: boolean;
+}
+/**
+ * Options for database selection
+ */
+export interface DatabaseSelectionOptions {
+    showSelectAll?: boolean;
+    allowNewOnly?: boolean;
+    defaultSelected?: string[];
+}
+/**
+ * Options for table selection
+ */
+export interface TableSelectionOptions {
+    showSelectAll?: boolean;
+    allowNewOnly?: boolean;
+    defaultSelected?: string[];
+    showDatabaseContext?: boolean;
+}
+/**
+ * Options for bucket selection
+ */
+export interface BucketSelectionOptions {
+    showSelectAll?: boolean;
+    allowNewOnly?: boolean;
+    defaultSelected?: string[];
+    groupByDatabase?: boolean;
+}
+/**
+ * Response from existing config prompt
+ */
+export interface ExistingConfigResponse {
+    syncExisting: boolean;
+    modifyConfiguration: boolean;
+}
+/**
+ * Comprehensive selection dialog system for enhanced sync flow
+ *
+ * This class provides interactive dialogs for selecting databases, tables/collections,
+ * and storage buckets during sync operations. It supports both new and existing
+ * configurations with visual indicators and comprehensive confirmation flows.
+ *
+ * @example
+ * ```typescript
+ * import { SelectionDialogs } from './shared/selectionDialogs.js';
+ * import type { Models } from 'node-appwrite';
+ *
+ * // Example usage in a sync command
+ * const availableDatabases: Models.Database[] = await getAvailableDatabases();
+ * const configuredDatabases = config.databases || [];
+ *
+ * // Prompt about existing configuration
+ * const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+ *
+ * if (modifyConfiguration) {
+ *   // Select databases
+ *   const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+ *     availableDatabases,
+ *     configuredDatabases,
+ *     { showSelectAll: true, allowNewOnly: !syncExisting }
+ *   );
+ *
+ *   // For each database, select tables
+ *   const tableSelectionsMap = new Map<string, string[]>();
+ *   const availableTablesMap = new Map<string, any[]>();
+ *
+ *   for (const databaseId of selectedDatabaseIds) {
+ *     const database = availableDatabases.find(db => db.$id === databaseId)!;
+ *     const availableTables = await getTablesForDatabase(databaseId);
+ *     const configuredTables = getConfiguredTablesForDatabase(databaseId);
+ *
+ *     availableTablesMap.set(databaseId, availableTables);
+ *
+ *     const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+ *       databaseId,
+ *       database.name,
+ *       availableTables,
+ *       configuredTables,
+ *       { showSelectAll: true, allowNewOnly: !syncExisting }
+ *     );
+ *
+ *     tableSelectionsMap.set(databaseId, selectedTableIds);
+ *   }
+ *
+ *   // Select buckets
+ *   const availableBuckets = await getAvailableBuckets();
+ *   const configuredBuckets = config.buckets || [];
+ *   const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+ *     selectedDatabaseIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     { showSelectAll: true, groupByDatabase: true }
+ *   );
+ *
+ *   // Create selection objects
+ *   const databaseSelections = SelectionDialogs.createDatabaseSelection(
+ *     selectedDatabaseIds,
+ *     availableDatabases,
+ *     tableSelectionsMap,
+ *     configuredDatabases,
+ *     availableTablesMap
+ *   );
+ *
+ *   const bucketSelections = SelectionDialogs.createBucketSelection(
+ *     selectedBucketIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     availableDatabases
+ *   );
+ *
+ *   // Show final confirmation
+ *   const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+ *     databaseSelections,
+ *     bucketSelections
+ *   );
+ *
+ *   const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+ *
+ *   if (confirmed) {
+ *     // Proceed with sync operation
+ *     await performSync(databaseSelections, bucketSelections);
+ *   }
+ * }
+ * ```
+ */
+export declare class SelectionDialogs {
+    /**
+     * Prompts user about existing configuration
+     */
+    static promptForExistingConfig(configuredItems: any[]): Promise<ExistingConfigResponse>;
+    /**
+     * Shows database selection dialog with indicators for configured vs new databases
+     */
+    static selectDatabases(availableDatabases: Models.Database[], configuredDatabases: any[], options?: DatabaseSelectionOptions): Promise<string[]>;
+    /**
+     * Shows table/collection selection dialog for a specific database
+     */
+    static selectTablesForDatabase(databaseId: string, databaseName: string, availableTables: any[], configuredTables: any[], options?: TableSelectionOptions): Promise<string[]>;
+    /**
+     * Shows bucket selection dialog for selected databases
+     */
+    static selectBucketsForDatabases(selectedDatabaseIds: string[], availableBuckets: any[], configuredBuckets: any[], options?: BucketSelectionOptions): Promise<string[]>;
+    /**
+     * Shows final confirmation dialog with sync selection summary
+     */
+    static confirmSyncSelection(selectionSummary: SyncSelectionSummary, operationType?: 'push' | 'pull' | 'sync'): Promise<boolean>;
+    /**
+     * Creates a sync selection summary from selected items
+     */
+    static createSyncSelectionSummary(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): SyncSelectionSummary;
+    /**
+     * Helper method to create database selection objects
+     */
+    static createDatabaseSelection(selectedDatabaseIds: string[], availableDatabases: Models.Database[], tableSelectionsMap: Map<string, string[]>, configuredDatabases: any[], availableTablesMap?: Map<string, any[]>): DatabaseSelection[];
+    /**
+     * Helper method to create bucket selection objects
+     */
+    static createBucketSelection(selectedBucketIds: string[], availableBuckets: any[], configuredBuckets: any[], availableDatabases: Models.Database[]): BucketSelection[];
+    /**
+     * Shows a progress message during selection operations
+     */
+    static showProgress(message: string): void;
+    /**
+     * Shows an error message and handles graceful cancellation
+     */
+    static showError(message: string, error?: Error): void;
+    /**
+     * Shows a warning message
+     */
+    static showWarning(message: string): void;
+    /**
+     * Shows a success message
+     */
+    static showSuccess(message: string): void;
+}