appwrite-utils-cli 1.8.3 → 1.8.6

package/CHANGELOG.md

@@ -11,4 +11,9 @@ All notable changes to this project will be documented in this file.
 - Multi-database targeting supported via `databaseIds` (alongside `databaseId`) on table/collection definitions.
 - Per-function configuration discovery via `.fnconfig.yaml` anywhere in the repository. Relative `dirPath` resolves from the file’s directory; `~` expands to homedir.
 - TablesDB/legacy detection is fetch-based; no additional SDK packages required.
-
+- New: Python (Pydantic) model generation with modern typing (PEP 604 unions) and Appwrite alias mapping. Generates:
+  - `base.py` (always overwritten) with aliased $id/$createdAt/$updatedAt/$permissions and helpers
+  - One model per collection/table extending `BaseAppwriteModel`
+  - Output directory selectable during interactive flow (absolute paths respected)
+- Constants generator now supports selecting which categories to include (databases, collections/tables, buckets, functions).
+- Bucket management: interactive create/delete commands with YAML persistence when active; selective push now diffs and updates bucket settings (name, permissions, security, limits).

package/README.md

@@ -34,13 +34,13 @@ Highlights:
 - **File Operations**: Complete file handling with URL downloads, local file search, and afterImportActions
 - **Backup Management**: Comprehensive backup system with progress tracking and detailed reporting
 
-### Development Tools
-- **Database Migrations**: Full migration control with progress tracking and operation summaries
-- **Schema Generation**: Generate TypeScript and JSON schemas from database configurations
-- **Constants Generation**: Generate cross-language constants files (TypeScript, Python, PHP, Dart, JSON, Env) for database, collection, bucket, and function IDs
-- **Data Transfer**: Transfer data between databases, collections, and instances with real-time progress
-- **Configuration Sync**: Bidirectional synchronization between local YAML configs and Appwrite projects
-- **Function Management**: Deploy and manage Appwrite Functions with specification updates
+### Development Tools
+- **Database Migrations**: Full migration control with progress tracking and operation summaries
+- **Schema Generation**: Generate TypeScript (Zod), JSON, and Python (Pydantic) schemas/models from database configurations
+- **Constants Generation**: Generate cross-language constants files (TypeScript, Python, PHP, Dart, JSON, Env) for database, collection, bucket, and function IDs
+- **Data Transfer**: Transfer data between databases, collections, and instances with real-time progress
+- **Configuration Sync**: Bidirectional synchronization between local YAML configs and Appwrite projects
+- **Function Management**: Deploy and manage Appwrite Functions with specification updates
 
 ## Installation
 
@@ -213,7 +213,7 @@ logging:
 
 After installation, you can access the tool directly from your command line using the provided commands.
 
-### Interactive Mode
+### Interactive Mode
 
 Run the CLI in interactive mode with enhanced visual feedback:
 
@@ -221,11 +221,28 @@ Run the CLI in interactive mode with enhanced visual feedback:
 npx --package=appwrite-utils-cli@latest appwrite-migrate --it
 ```
 
-This provides a professional guided experience with:
-- Rich visual feedback and progress tracking
-- Smart confirmation dialogs for destructive operations
-- Operation summaries with detailed statistics
-- Real-time progress bars with ETA calculations
+This provides a professional guided experience with:
+- Rich visual feedback and progress tracking
+- Smart confirmation dialogs for destructive operations
+- Operation summaries with detailed statistics
+- Real-time progress bars with ETA calculations
+
+### Generate Schemas (Zod / JSON / Pydantic)
+
+Interactive schema generation lets you pick the format and output directory:
+
+```bash
+npx appwrite-utils-cli appwrite-migrate --it
+# Choose: Generate schemas
+# Select: TypeScript (Zod), JSON, Python (Pydantic), or All
+# Enter output directory (absolute path respected)
+```
+
+- Pydantic models use modern typing (str | None, list[str]) and alias mapping for Appwrite system fields:
+  - Base model (written as `base.py`) defines aliases for `$id`, `$createdAt`, `$updatedAt`, `$permissions`, `$databaseId`, `$collectionId`, `$sequence`.
+  - Each collection/table generates a model extending `BaseAppwriteModel`.
+  - Serialize with aliases via `model_dump(by_alias=True)` and validate from Appwrite docs via `model_validate(...)`.
+  - Output directory is selectable; files are written directly to your chosen path (no extra subfolder).
 
 ### Push (manual selection)
 
@@ -1102,3 +1119,15 @@ Rules:
 - `.fnconfig.yaml` definitions merge with central `.appwrite/config.yaml` functions; if the same `$id` exists in both, `.fnconfig.yaml` overrides
 
 Deployment uses the merged function set and resolves paths according to these rules.
+### Generate Constants
+
+Select which languages and which categories to generate (databases, collections/tables, buckets, functions):
+
+```bash
+npx appwrite-utils-cli appwrite-migrate --it
+# Choose: Generate cross-language constants
+# Select languages (TS/JS/Python/PHP/Dart/JSON/Env)
+# Select categories to include
+```
+
+Constants are written to a configurable output directory under `.appwrite/` by default.

package/dist/adapters/TablesDBAdapter.js

@@ -192,7 +192,7 @@ export class TablesDBAdapter extends BaseAdapter {
             const type = (params.type || "").toLowerCase();
             const required = params.required ?? false;
             const array = params.array ?? false;
-            const encrypt = params.encrypt ?? params.encrypted ?? false;
+            const encrypt = params.encrypt ?? false;
             const normalizedDefault = params.default === null || params.default === undefined
                 ? undefined
                 : params.default;

package/dist/cli/commands/functionCommands.js

@@ -111,11 +111,38 @@ export const functionCommands = {
             MessageFormatter.error("Failed to initialize controller or load config", undefined, { prefix: "Functions" });
             return;
         }
-        // Discover local .fnconfig.yaml functions and merge into controller config
+        // Offer choice of function config sources: central YAML, .fnconfig.yaml, or both
+        let sourceChoice = 'both';
+        try {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'source',
+                    message: 'Select function config source:',
+                    choices: [
+                        { name: 'config.yaml functions (central)', value: 'central' },
+                        { name: '.fnconfig.yaml (discovered per-function)', value: 'fnconfig' },
+                        { name: 'Both (merge; .fnconfig overrides)', value: 'both' },
+                    ],
+                    default: 'both'
+                }
+            ]);
+            sourceChoice = answer.source;
+        }
+        catch { }
         try {
             const discovered = discoverFnConfigs(cli.currentDir);
-            const merged = mergeDiscoveredFunctions(cli.controller.config.functions || [], discovered);
-            cli.controller.config.functions = merged;
+            const central = cli.controller.config.functions || [];
+            if (sourceChoice === 'central') {
+                cli.controller.config.functions = central;
+            }
+            else if (sourceChoice === 'fnconfig') {
+                cli.controller.config.functions = discovered;
+            }
+            else {
+                const merged = mergeDiscoveredFunctions(central, discovered);
+                cli.controller.config.functions = merged;
+            }
         }
         catch { }
         const functions = await cli.selectFunctions("Select function(s) to deploy:", true, true);

package/dist/cli/commands/schemaCommands.js

@@ -17,9 +17,11 @@ export const schemaCommands = {
                 choices: [
                     { name: "TypeScript (Zod) schemas", value: "zod" },
                     { name: "JSON schemas", value: "json" },
-                    { name: "Both TypeScript and JSON schemas", value: "both" },
+                    { name: "Python (Pydantic) models", value: "pydantic" },
+                    { name: "TypeScript + JSON", value: "both" },
+                    { name: "All (Zod, JSON, Pydantic)", value: "all" },
                 ],
-                default: "both",
+                default: "all",
             },
         ]);
         // Get the config folder path (where the config file is located)
@@ -28,9 +30,21 @@ export const schemaCommands = {
             MessageFormatter.error("Failed to get config folder path", undefined, { prefix: "Schemas" });
             return;
         }
+        // Prompt for schema output directory (optional override)
+        const defaultSchemaOut = path.join(configFolderPath, cli.controller.config?.schemaConfig?.outputDirectory || 'schemas');
+        const { schemaOutDir } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'schemaOutDir',
+                message: 'Output directory for schemas:',
+                default: defaultSchemaOut,
+                validate: (input) => input && input.trim().length > 0 ? true : 'Please provide an output directory',
+            }
+        ]);
         // Create SchemaGenerator with the correct base path and generate schemas
         const schemaGenerator = new SchemaGenerator(cli.controller.config, configFolderPath);
-        schemaGenerator.generateSchemas({ format: schemaType, verbose: true });
+        const outDirRel = path.isAbsolute(schemaOutDir) ? schemaOutDir : path.relative(configFolderPath, schemaOutDir);
+        await schemaGenerator.generateSchemas({ format: schemaType, verbose: true, outputDir: outDirRel });
         MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
     },
     async generateConstants(cli) {
@@ -62,6 +76,21 @@ export const schemaCommands = {
                 },
             },
         ]);
+        // Prompt for which constants to include
+        const { includeWhat } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'includeWhat',
+                message: 'Select which constants to generate:',
+                choices: [
+                    { name: 'Databases', value: 'databases', checked: true },
+                    { name: 'Collections/Tables', value: 'collections', checked: true },
+                    { name: 'Buckets', value: 'buckets', checked: true },
+                    { name: 'Functions', value: 'functions', checked: true },
+                ],
+                validate: (input) => input.length > 0 ? true : 'Select at least one category',
+            }
+        ]);
         // Determine default output directory based on config location
         const configPath = cli.controller.getAppwriteFolderPath();
         const defaultOutputDir = configPath
@@ -85,8 +114,14 @@ export const schemaCommands = {
         try {
             const { ConstantsGenerator } = await import("../../utils/constantsGenerator.js");
             const generator = new ConstantsGenerator(cli.controller.config);
+            const include = {
+                databases: includeWhat.includes('databases'),
+                collections: includeWhat.includes('collections'),
+                buckets: includeWhat.includes('buckets'),
+                functions: includeWhat.includes('functions'),
+            };
             MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
-            await generator.generateFiles(languages, outputDir);
+            await generator.generateFiles(languages, outputDir, include);
             MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
         }
         catch (error) {

package/dist/cli/commands/storageCommands.d.ts

@@ -0,0 +1,5 @@
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare const storageCommands: {
+    createBucket(cli: InteractiveCLI): Promise<void>;
+    deleteBuckets(cli: InteractiveCLI): Promise<void>;
+};

package/dist/cli/commands/storageCommands.js

@@ -0,0 +1,143 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { Storage, Permission, Role, Compression } from "node-appwrite";
+import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { listBuckets, createBucket as createBucketApi, deleteBucket as deleteBucketApi } from "../../storage/methods.js";
+import { writeYamlConfig } from "../../config/yamlConfig.js";
+import { ConfigManager } from "../../config/ConfigManager.js";
+export const storageCommands = {
+    async createBucket(cli) {
+        const storage = cli.controller.storage;
+        if (!storage) {
+            MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
+            return;
+        }
+        const answers = await inquirer.prompt([
+            { type: 'input', name: 'name', message: 'Bucket name:', validate: (v) => v?.trim()?.length > 0 || 'Required' },
+            { type: 'input', name: 'id', message: 'Bucket ID (optional):' },
+            { type: 'confirm', name: 'publicRead', message: 'Public read access?', default: false },
+            { type: 'confirm', name: 'fileSecurity', message: 'Enable file-level security?', default: false },
+            { type: 'confirm', name: 'enabled', message: 'Enable bucket?', default: true },
+            { type: 'number', name: 'maximumFileSize', message: 'Max file size (bytes, optional):', default: undefined },
+            { type: 'input', name: 'allowedFileExtensions', message: 'Allowed extensions (comma separated, optional):', default: '' },
+            { type: 'list', name: 'compression', message: 'Compression:', choices: ['none', 'gzip', 'zstd'], default: 'none' },
+            { type: 'confirm', name: 'encryption', message: 'Enable encryption?', default: false },
+            { type: 'confirm', name: 'antivirus', message: 'Enable antivirus?', default: false },
+        ]);
+        const permissions = [];
+        if (answers.publicRead)
+            permissions.push(Permission.read(Role.any()));
+        const bucketInput = {
+            name: answers.name,
+            $permissions: permissions,
+            fileSecurity: !!answers.fileSecurity,
+            enabled: !!answers.enabled,
+            maximumFileSize: answers.maximumFileSize || undefined,
+            allowedFileExtensions: String(answers.allowedFileExtensions || '')
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean),
+            compression: answers.compression,
+            encryption: !!answers.encryption,
+            antivirus: !!answers.antivirus,
+        };
+        try {
+            const created = await createBucketApi(storage, bucketInput, answers.id || undefined);
+            MessageFormatter.success(`Bucket '${answers.name}' created`, { prefix: 'Buckets' });
+            // Update in-memory config and persist to YAML as a global bucket entry
+            const controller = cli.controller;
+            controller.config.buckets = controller.config.buckets || [];
+            controller.config.buckets.push({
+                $id: created.$id || answers.id || bucketInput.name,
+                name: bucketInput.name,
+                permissions: [],
+                fileSecurity: bucketInput.fileSecurity,
+                enabled: bucketInput.enabled,
+                maximumFileSize: bucketInput.maximumFileSize,
+                allowedFileExtensions: bucketInput.allowedFileExtensions,
+                compression: bucketInput.compression,
+                encryption: bucketInput.encryption,
+                antivirus: bucketInput.antivirus,
+            });
+            const cfgMgr = ConfigManager.getInstance();
+            const cfgPath = cfgMgr.getConfigPath();
+            if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
+                await writeYamlConfig(cfgPath, controller.config);
+                MessageFormatter.info(`Added bucket to config.yaml`, { prefix: 'Buckets' });
+            }
+            else {
+                MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.error('Failed to create bucket', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
+        }
+    },
+    async deleteBuckets(cli) {
+        const storage = cli.controller.storage;
+        if (!storage) {
+            MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
+            return;
+        }
+        try {
+            const res = await listBuckets(storage);
+            const buckets = res.buckets || [];
+            if (buckets.length === 0) {
+                MessageFormatter.info('No buckets found', { prefix: 'Buckets' });
+                return;
+            }
+            const { toDelete } = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'toDelete',
+                    message: chalk.red('Select buckets to delete:'),
+                    choices: buckets.map((b) => ({ name: `${b.name} (${b.$id})`, value: b.$id })),
+                    pageSize: 10,
+                }
+            ]);
+            if (!toDelete || toDelete.length === 0) {
+                MessageFormatter.info('No buckets selected', { prefix: 'Buckets' });
+                return;
+            }
+            const { confirm } = await inquirer.prompt([
+                { type: 'confirm', name: 'confirm', message: `Delete ${toDelete.length} bucket(s)?`, default: false }
+            ]);
+            if (!confirm)
+                return;
+            const controller = cli.controller;
+            for (const id of toDelete) {
+                try {
+                    await deleteBucketApi(storage, id);
+                    MessageFormatter.success(`Deleted bucket ${id}`, { prefix: 'Buckets' });
+                    // Remove from in-memory config (global buckets)
+                    if (Array.isArray(controller.config.buckets)) {
+                        controller.config.buckets = controller.config.buckets.filter((b) => b.$id !== id);
+                    }
+                    // Clear database-linked bucket references if matching
+                    if (Array.isArray(controller.config.databases)) {
+                        controller.config.databases = controller.config.databases.map((db) => ({
+                            ...db,
+                            bucket: db.bucket && db.bucket.$id === id ? undefined : db.bucket,
+                        }));
+                    }
+                }
+                catch (e) {
+                    MessageFormatter.error(`Failed to delete bucket ${id}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
+                }
+            }
+            // Persist YAML changes
+            const cfgMgr = ConfigManager.getInstance();
+            const cfgPath = cfgMgr.getConfigPath();
+            if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
+                await writeYamlConfig(cfgPath, controller.config);
+                MessageFormatter.info(`Updated config.yaml after deletion`, { prefix: 'Buckets' });
+            }
+            else {
+                MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.error('Failed to list buckets', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
+        }
+    }
+};

package/dist/collections/attributes.js

@@ -266,8 +266,8 @@ const createAttributeViaAdapter = async (db, dbId, collectionId, attribute) => {
             ...(attribute.size && { size: attribute.size }),
             ...(attribute.xdefault !== undefined &&
                 !attribute.required && { default: attribute.xdefault }),
-            ...(attribute.encrypted && {
-                encrypt: attribute.encrypted,
+            ...(attribute.encrypt && {
+                encrypt: attribute.encrypt,
             }),
             ...(attribute.min !== undefined && {
                 min: attribute.min,
@@ -334,7 +334,7 @@ const updateAttributeViaAdapter = async (db, dbId, collectionId, attribute) => {
             size: attribute.size,
             min: attribute.min,
             max: attribute.max,
-            encrypt: attribute.encrypted ?? attribute.encrypt,
+            encrypt: attribute.encrypt,
             elements: attribute.elements,
             relatedCollection: attribute.relatedCollection,
             relationType: attribute.relationType,
@@ -375,13 +375,13 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
                     ? attribute.xdefault
                     : undefined,
                 array: attribute.array || false,
-                encrypted: attribute.encrypted,
+                encrypt: attribute.encrypt,
             };
             logger.debug(`Creating string attribute '${attribute.key}'`, {
                 ...stringParams,
                 operation: "createLegacyAttribute",
             });
-            await db.createStringAttribute(dbId, collectionId, attribute.key, stringParams.size, stringParams.required, stringParams.defaultValue, stringParams.array, stringParams.encrypted);
+            await db.createStringAttribute(dbId, collectionId, attribute.key, stringParams.size, stringParams.required, stringParams.defaultValue, stringParams.array, stringParams.encrypt);
             break;
         case "integer":
             const integerParams = {
@@ -686,7 +686,7 @@ const getComparableFields = (type) => {
     const baseFields = ["key", "type", "array", "required", "xdefault"];
     switch (type) {
         case "string":
-            return [...baseFields, "size", "encrypted"];
+            return [...baseFields, "size", "encrypt"];
         case "integer":
         case "double":
         case "float":
@@ -714,7 +714,7 @@ const getComparableFields = (type) => {
                 "key",
                 "type",
                 "array",
-                "encrypted",
+                "encrypt",
                 "required",
                 "size",
                 "min",

package/dist/collections/methods.js

@@ -118,7 +118,7 @@ export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) =>
 };
 export const generateSchemas = async (config, appwriteFolderPath) => {
     const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
-    schemaGenerator.generateSchemas();
+    await schemaGenerator.generateSchemas();
 };
 export const createOrUpdateCollections = async (database, databaseId, config, deletedCollections, selectedCollections = []) => {
     // Clear processing state at the start of a new operation
@@ -235,6 +235,11 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
             const plusminus = plan.toUpdate.map((u) => u.attribute.key);
             const minus = plan.toRecreate.map((r) => r.newAttribute.key);
             const skip = plan.unchanged;
+            // Compute deletions (remote extras not present locally)
+            const desiredKeysForDelete = new Set((attributes || []).map((a) => a.key));
+            const extraRemoteKeys = (existingCols || [])
+                .map((c) => c?.key)
+                .filter((k) => !!k && !desiredKeysForDelete.has(k));
             const parts = [];
             if (plus.length)
                 parts.push(`➕  ${plus.length} (${plus.join(', ')})`);
@@ -244,6 +249,7 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 parts.push(`♻️  ${minus.length} (${minus.join(', ')})`);
             if (skip.length)
                 parts.push(`⏭️  ${skip.length}`);
+            parts.push(`🗑️  ${extraRemoteKeys.length}${extraRemoteKeys.length ? ` (${extraRemoteKeys.join(', ')})` : ''}`);
             MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Attributes' });
             // Execute
             const colResults = await executeColumnOperations(adapter, databaseId, tableId, plan);
@@ -458,6 +464,121 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         catch (e) {
             MessageFormatter.error(`Failed to list/create indexes`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
         }
+        // Deletions for indexes: remove remote indexes not declared in YAML/config
+        try {
+            const desiredIndexKeys = new Set((indexes || []).map((i) => i.key));
+            const idxRes = await adapter.listIndexes({ databaseId, tableId });
+            const existingIdx = idxRes.data || idxRes.indexes || [];
+            const extraIdx = existingIdx
+                .filter((i) => i?.key && !desiredIndexKeys.has(i.key))
+                .map((i) => i.key);
+            if (extraIdx.length > 0) {
+                MessageFormatter.info(`Plan → 🗑️  ${extraIdx.length} indexes (${extraIdx.join(', ')})`, { prefix: 'Indexes' });
+                const deleted = [];
+                const errors = [];
+                for (const key of extraIdx) {
+                    try {
+                        await adapter.deleteIndex({ databaseId, tableId, key });
+                        // Optionally wait for index to disappear
+                        const start = Date.now();
+                        const maxWait = 30000;
+                        while (Date.now() - start < maxWait) {
+                            try {
+                                const li = await adapter.listIndexes({ databaseId, tableId });
+                                const list = li.data || li.indexes || [];
+                                if (!list.find((ix) => ix.key === key))
+                                    break;
+                            }
+                            catch { }
+                            await delay(1000);
+                        }
+                        deleted.push(key);
+                    }
+                    catch (e) {
+                        errors.push({ key, error: e?.message || String(e) });
+                    }
+                }
+                if (deleted.length) {
+                    MessageFormatter.success(`Deleted ${deleted.length} indexes: ${deleted.join(', ')}`, { prefix: 'Indexes' });
+                }
+                if (errors.length) {
+                    MessageFormatter.error(`${errors.length} index deletions failed`, undefined, { prefix: 'Indexes' });
+                    errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Indexes' }));
+                }
+            }
+            else {
+                MessageFormatter.info(`Plan → 🗑️  0 indexes`, { prefix: 'Indexes' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.warning(`Could not evaluate index deletions: ${e?.message || e}`, { prefix: 'Indexes' });
+        }
+        // Deletions: remove columns/attributes that are present remotely but not in desired config
+        try {
+            const desiredKeys = new Set((attributes || []).map((a) => a.key));
+            const tableInfo3 = await adapter.getTable({ databaseId, tableId });
+            const existingCols3 = tableInfo3.data?.columns || tableInfo3.data?.attributes || [];
+            const toDelete = existingCols3
+                .filter((col) => col?.key && !desiredKeys.has(col.key))
+                .map((col) => col.key);
+            if (toDelete.length > 0) {
+                MessageFormatter.info(`Plan → 🗑️  ${toDelete.length} (${toDelete.join(', ')})`, { prefix: 'Attributes' });
+                const deleted = [];
+                const errors = [];
+                for (const key of toDelete) {
+                    try {
+                        // Drop any indexes that reference this attribute to avoid server errors
+                        try {
+                            const idxRes = await adapter.listIndexes({ databaseId, tableId });
+                            const ilist = idxRes.data || idxRes.indexes || [];
+                            for (const idx of ilist) {
+                                const attrs = Array.isArray(idx.attributes) ? idx.attributes : [];
+                                if (attrs.includes(key)) {
+                                    MessageFormatter.info(`🗑️  Deleting index '${idx.key}' referencing '${key}'`, { prefix: 'Indexes' });
+                                    await adapter.deleteIndex({ databaseId, tableId, key: idx.key });
+                                    await delay(500);
+                                }
+                            }
+                        }
+                        catch { }
+                        await adapter.deleteAttribute({ databaseId, tableId, key });
+                        // Wait briefly for deletion to settle
+                        const start = Date.now();
+                        const maxWaitMs = 60000;
+                        while (Date.now() - start < maxWaitMs) {
+                            try {
+                                const tinfo = await adapter.getTable({ databaseId, tableId });
+                                const cols = tinfo.data?.columns || tinfo.data?.attributes || [];
+                                const found = cols.find((c) => c.key === key);
+                                if (!found)
+                                    break;
+                                if (found.status && found.status !== 'deleting')
+                                    break;
+                            }
+                            catch { }
+                            await delay(1000);
+                        }
+                        deleted.push(key);
+                    }
+                    catch (e) {
+                        errors.push({ key, error: e?.message || String(e) });
+                    }
+                }
+                if (deleted.length) {
+                    MessageFormatter.success(`Deleted ${deleted.length} attributes: ${deleted.join(', ')}`, { prefix: 'Attributes' });
+                }
+                if (errors.length) {
+                    MessageFormatter.error(`${errors.length} deletions failed`, undefined, { prefix: 'Attributes' });
+                    errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Attributes' }));
+                }
+            }
+            else {
+                MessageFormatter.info(`Plan → 🗑️  0`, { prefix: 'Attributes' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.warning(`Could not evaluate deletions: ${e?.message || e}`, { prefix: 'Attributes' });
+        }
         // Mark this table as fully processed to prevent re-processing
         markCollectionProcessed(tableId, collectionData.name);
     }

package/dist/collections/tableOperations.js

@@ -62,7 +62,7 @@ export function normalizeAttributeToComparable(attr) {
     };
     if (t === 'string') {
         base.size = attr.size ?? 255;
-        base.encrypt = !!(attr.encrypted ?? attr.encrypt);
+        base.encrypt = !!(attr.encrypt);
     }
     if (t === 'integer' || t === 'float' || t === 'double') {
         const min = toNumber(attr.min);
@@ -220,7 +220,7 @@ function compareColumnProperties(oldColumn, newAttribute, columnType) {
         if (prop === 'default')
             return na.xdefault;
         if (prop === 'encrypt')
-            return na.encrypted ?? na.encrypt;
+            return na.encrypt;
         return na[prop];
     };
     const getOldVal = (prop) => {

package/dist/interactiveCLI.d.ts

@@ -5,6 +5,7 @@ export declare class InteractiveCLI {
     constructor(currentDir: string);
     run(): Promise<void>;
     private initControllerIfNeeded;
+    private manageBuckets;
     private selectDatabases;
     private selectCollections;
     /**

package/dist/interactiveCLI.js

@@ -19,6 +19,7 @@ import { findYamlConfig } from "./config/yamlConfig.js";
 import { configCommands } from "./cli/commands/configCommands.js";
 import { databaseCommands } from "./cli/commands/databaseCommands.js";
 import { functionCommands } from "./cli/commands/functionCommands.js";
+import { storageCommands } from "./cli/commands/storageCommands.js";
 import { transferCommands } from "./cli/commands/transferCommands.js";
 import { schemaCommands } from "./cli/commands/schemaCommands.js";
 var CHOICES;
@@ -44,6 +45,7 @@ var CHOICES;
     CHOICES["IMPORT_DATA"] = "\uD83D\uDCE5 Import data";
     CHOICES["RELOAD_CONFIG"] = "\uD83D\uDD04 Reload configuration files";
     CHOICES["UPDATE_FUNCTION_SPEC"] = "\u2699\uFE0F Update function specifications";
+    CHOICES["MANAGE_BUCKETS"] = "\uD83E\uDEA3 Manage storage buckets";
     CHOICES["EXIT"] = "\uD83D\uDC4B Exit";
 })(CHOICES || (CHOICES = {}));
 export class InteractiveCLI {
@@ -152,6 +154,9 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await functionCommands.updateFunctionSpec(this);
                     break;
+                case CHOICES.MANAGE_BUCKETS:
+                    await this.manageBuckets();
+                    break;
                 case CHOICES.EXIT:
                     MessageFormatter.success("Goodbye!");
                     process.exit(0);
@@ -187,6 +192,31 @@ export class InteractiveCLI {
             // If no directConfig provided, keep existing controller
         }
     }
+    async manageBuckets() {
+        await this.initControllerIfNeeded();
+        while (true) {
+            const { action } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: chalk.blue('Bucket management'),
+                    choices: [
+                        { name: 'Create bucket', value: 'create' },
+                        { name: 'Delete buckets', value: 'delete' },
+                        { name: 'Back', value: 'back' },
+                    ],
+                },
+            ]);
+            if (action === 'back')
+                break;
+            if (action === 'create') {
+                await storageCommands.createBucket(this);
+            }
+            else if (action === 'delete') {
+                await storageCommands.deleteBuckets(this);
+            }
+        }
+    }
     async selectDatabases(databases, message, multiSelect = true) {
         await this.initControllerIfNeeded();
         const configDatabases = this.getLocalDatabases();