appwrite-utils-cli 1.8.3 → 1.8.6

package/src/cli/commands/storageCommands.ts

@@ -0,0 +1,152 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { Storage, Permission, Role, Compression, type Models } from "node-appwrite";
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+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: InteractiveCLI): Promise<void> {
+    const storage: Storage = (cli as any).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:string)=> 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: string[] = [];
+    if (answers.publicRead) permissions.push(Permission.read(Role.any()));
+
+    const bucketInput: Omit<Models.Bucket, "$id" | "$createdAt" | "$updatedAt"> = {
+      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 as Compression,
+      encryption: !!answers.encryption,
+      antivirus: !!answers.antivirus,
+    } as any;
+
+    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 as any).controller!;
+      controller.config.buckets = controller.config.buckets || [];
+      controller.config.buckets.push({
+        $id: (created as any).$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: InteractiveCLI): Promise<void> {
+    const storage: Storage = (cli as any).controller!.storage!;
+    if (!storage) {
+      MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
+      return;
+    }
+
+    try {
+      const res = await listBuckets(storage);
+      const buckets: Models.Bucket[] = 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 as any).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: any) => b.$id !== id);
+          }
+          // Clear database-linked bucket references if matching
+          if (Array.isArray(controller.config.databases)) {
+            controller.config.databases = controller.config.databases.map((db: any) => ({
+              ...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/src/collections/attributes.ts

@@ -325,8 +325,8 @@ const createAttributeViaAdapter = async (
       ...((attribute as any).size && { size: (attribute as any).size }),
       ...((attribute as any).xdefault !== undefined &&
         !attribute.required && { default: (attribute as any).xdefault }),
-      ...((attribute as any).encrypted && {
-        encrypt: (attribute as any).encrypted,
+      ...((attribute as any).encrypt && {
+        encrypt: (attribute as any).encrypt,
       }),
       ...((attribute as any).min !== undefined && {
         min: (attribute as any).min,
@@ -408,7 +408,7 @@ const updateAttributeViaAdapter = async (
       size: (attribute as any).size,
       min: (attribute as any).min,
       max: (attribute as any).max,
-      encrypt: (attribute as any).encrypted ?? (attribute as any).encrypt,
+      encrypt: (attribute as any).encrypt,
       elements: (attribute as any).elements,
       relatedCollection: (attribute as any).relatedCollection,
       relationType: (attribute as any).relationType,
@@ -458,7 +458,7 @@ const createLegacyAttribute = async (
             ? (attribute as any).xdefault
             : undefined,
         array: attribute.array || false,
-        encrypted: (attribute as any).encrypted,
+        encrypt: (attribute as any).encrypt,
       };
       logger.debug(`Creating string attribute '${attribute.key}'`, {
         ...stringParams,
@@ -472,7 +472,7 @@ const createLegacyAttribute = async (
         stringParams.required,
         stringParams.defaultValue,
         stringParams.array,
-        stringParams.encrypted
+        stringParams.encrypt
       );
       break;
     case "integer":
@@ -1055,7 +1055,7 @@ const getComparableFields = (type: string): string[] => {
 
   switch (type) {
     case "string":
-      return [...baseFields, "size", "encrypted"];
+      return [...baseFields, "size", "encrypt"];
 
     case "integer":
     case "double":
@@ -1088,7 +1088,7 @@ const getComparableFields = (type: string): string[] => {
         "key",
         "type",
         "array",
-        "encrypted",
+        "encrypt",
         "required",
         "size",
         "min",

package/src/collections/methods.ts

@@ -176,13 +176,13 @@ export const fetchAndCacheCollectionByName = async (
   }
 };
 
-export const generateSchemas = async (
-  config: AppwriteConfig,
-  appwriteFolderPath: string
-): Promise<void> => {
-  const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
-  schemaGenerator.generateSchemas();
-};
+export const generateSchemas = async (
+  config: AppwriteConfig,
+  appwriteFolderPath: string
+): Promise<void> => {
+  const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
+  await schemaGenerator.generateSchemas();
+};
 
 export const createOrUpdateCollections = async (
   database: Databases,
@@ -319,11 +319,18 @@ export const createOrUpdateCollectionsViaAdapter = async (
       const minus = plan.toRecreate.map((r: any) => (r.newAttribute as any).key);
       const skip = plan.unchanged;
 
+      // Compute deletions (remote extras not present locally)
+      const desiredKeysForDelete = new Set((attributes || []).map((a: any) => a.key));
+      const extraRemoteKeys = (existingCols || [])
+        .map((c: any) => c?.key)
+        .filter((k: any): k is string => !!k && !desiredKeysForDelete.has(k));
+
       const parts: string[] = [];
       if (plus.length) parts.push(`➕  ${plus.length} (${plus.join(', ')})`);
       if (plusminus.length) parts.push(`🔧  ${plusminus.length} (${plusminus.join(', ')})`);
       if (minus.length) 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
@@ -510,10 +517,117 @@ export const createOrUpdateCollectionsViaAdapter = async (
     } catch (e) {
       MessageFormatter.error(`Failed to list/create indexes`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
     }
-
-    // Mark this table as fully processed to prevent re-processing
-    markCollectionProcessed(tableId, collectionData.name);
-  }
+
+    // Deletions for indexes: remove remote indexes not declared in YAML/config
+    try {
+      const desiredIndexKeys = new Set((indexes || []).map((i: any) => i.key));
+      const idxRes = await adapter.listIndexes({ databaseId, tableId });
+      const existingIdx: any[] = (idxRes as any).data || (idxRes as any).indexes || [];
+      const extraIdx = existingIdx
+        .filter((i: any) => i?.key && !desiredIndexKeys.has(i.key))
+        .map((i: any) => i.key as string);
+      if (extraIdx.length > 0) {
+        MessageFormatter.info(`Plan → 🗑️  ${extraIdx.length} indexes (${extraIdx.join(', ')})`, { prefix: 'Indexes' });
+        const deleted: string[] = [];
+        const errors: Array<{ key: string; error: string }> = [];
+        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: any[] = (li as any).data || (li as any).indexes || [];
+                if (!list.find((ix: any) => ix.key === key)) break;
+              } catch {}
+              await delay(1000);
+            }
+            deleted.push(key);
+          } catch (e: any) {
+            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 as Error)?.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: any) => a.key));
+      const tableInfo3 = await adapter.getTable({ databaseId, tableId });
+      const existingCols3: any[] = (tableInfo3 as any).data?.columns || (tableInfo3 as any).data?.attributes || [];
+      const toDelete = existingCols3
+        .filter((col: any) => col?.key && !desiredKeys.has(col.key))
+        .map((col: any) => col.key as string);
+
+      if (toDelete.length > 0) {
+        MessageFormatter.info(`Plan → 🗑️  ${toDelete.length} (${toDelete.join(', ')})`, { prefix: 'Attributes' });
+        const deleted: string[] = [];
+        const errors: Array<{ key: string; error: string }> = [];
+        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: any[] = (idxRes as any).data || (idxRes as any).indexes || [];
+              for (const idx of ilist) {
+                const attrs: string[] = 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 as any).data?.columns || (tinfo as any).data?.attributes || [];
+                const found = cols.find((c: any) => c.key === key);
+                if (!found) break;
+                if (found.status && found.status !== 'deleting') break;
+              } catch {}
+              await delay(1000);
+            }
+            deleted.push(key);
+          } catch (e: any) {
+            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 as Error)?.message || e}`, { prefix: 'Attributes' });
+    }
+
+    // Mark this table as fully processed to prevent re-processing
+    markCollectionProcessed(tableId, collectionData.name);
+  }
 
   // Process queued relationships once mapping likely populated
   if (relQueue.length > 0) {

package/src/collections/tableOperations.ts

@@ -115,7 +115,7 @@ export function normalizeAttributeToComparable(attr: Attribute): ComparableColum
 
   if (t === 'string') {
     base.size = (attr as any).size ?? 255;
-    base.encrypt = !!((attr as any).encrypted ?? (attr as any).encrypt);
+    base.encrypt = !!((attr as any).encrypt);
   }
   if (t === 'integer' || t === 'float' || t === 'double') {
     const min = toNumber((attr as any).min);
@@ -261,7 +261,7 @@ function compareColumnProperties(
   const getNewVal = (prop: string) => {
     const na = newAttribute as any;
     if (prop === 'default') return na.xdefault;
-    if (prop === 'encrypt') return na.encrypted ?? na.encrypt;
+    if (prop === 'encrypt') return na.encrypt;
     return na[prop];
   };
   const getOldVal = (prop: string) => {

package/src/interactiveCLI.ts

@@ -42,11 +42,12 @@ import { findYamlConfig } from "./config/yamlConfig.js";
 // Import command modules
 import { configCommands } from "./cli/commands/configCommands.js";
 import { databaseCommands } from "./cli/commands/databaseCommands.js";
-import { functionCommands } from "./cli/commands/functionCommands.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";
 
-enum CHOICES {
+enum CHOICES {
   MIGRATE_CONFIG = "🔄 Migrate TypeScript config to YAML (.appwrite structure)",
   VALIDATE_CONFIG = "✅ Validate configuration (collections/tables conflicts)",
   MIGRATE_COLLECTIONS_TO_TABLES = "🔀 Migrate collections to tables format",
@@ -67,11 +68,12 @@ enum CHOICES {
   GENERATE_CONSTANTS = "📋 Generate cross-language constants (TypeScript, Python, PHP, Dart, etc.)",
   IMPORT_DATA = "📥 Import data",
   RELOAD_CONFIG = "🔄 Reload configuration files",
-  UPDATE_FUNCTION_SPEC = "⚙️ Update function specifications",
-  EXIT = "👋 Exit",
-}
+  UPDATE_FUNCTION_SPEC = "⚙️ Update function specifications",
+  MANAGE_BUCKETS = "🪣 Manage storage buckets",
+  EXIT = "👋 Exit",
+}
 
-export class InteractiveCLI {
+export class InteractiveCLI {
   private controller: UtilsController | undefined;
   private isUsingTypeScriptConfig: boolean = false;
 
@@ -180,10 +182,13 @@ export class InteractiveCLI {
         case CHOICES.RELOAD_CONFIG:
           await configCommands.reloadConfigWithSessionPreservation(this);
           break;
-        case CHOICES.UPDATE_FUNCTION_SPEC:
-          await this.initControllerIfNeeded();
-          await functionCommands.updateFunctionSpec(this);
-          break;
+        case CHOICES.UPDATE_FUNCTION_SPEC:
+          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);
@@ -191,7 +196,7 @@ export class InteractiveCLI {
     }
   }
 
-  private async initControllerIfNeeded(directConfig?: {
+  private async initControllerIfNeeded(directConfig?: {
     appwriteEndpoint: string;
     appwriteProject: string;
     appwriteKey: string;
@@ -222,7 +227,32 @@ export class InteractiveCLI {
       }
       // If no directConfig provided, keep existing controller
     }
-  }
+  }
+
+  private async manageBuckets(): Promise<void> {
+    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);
+      }
+    }
+  }
 
   private async selectDatabases(
     databases: Models.Database[],

package/src/main.ts

@@ -41,7 +41,7 @@ if (!(globalThis as any).require) {
   (globalThis as any).require = require;
 }
 
-interface CliOptions {
+interface CliOptions {
   config?: string;
   it?: boolean;
   dbIds?: string;
@@ -86,8 +86,13 @@ interface CliOptions {
   session?: string;
   listBackups?: boolean;
   autoSync?: boolean;
-  selectBuckets?: boolean;
-}
+  selectBuckets?: boolean;
+  // New schema/constant CLI flags
+  generateSchemas?: boolean;
+  schemaFormat?: 'zod' | 'json' | 'pydantic' | 'both' | 'all';
+  schemaOutDir?: string;
+  constantsInclude?: string;
+}
 
 type ParsedArgv = ArgumentsCamelCase<CliOptions>;
 
@@ -567,12 +572,30 @@ const argv = yargs(hideBin(process.argv))
       "Comma-separated list of languages for constants (typescript,javascript,python,php,dart,json,env)",
     default: "typescript",
   })
-  .option("constantsOutput", {
-    type: "string",
-    description:
-      "Output directory for generated constants files (default: config-folder/constants)",
-    default: "auto",
-  })
+  .option("constantsOutput", {
+    type: "string",
+    description:
+      "Output directory for generated constants files (default: config-folder/constants)",
+    default: "auto",
+  })
+  .option("constantsInclude", {
+    type: "string",
+    description:
+      "Comma-separated categories to include: databases,collections,buckets,functions",
+  })
+  .option("generateSchemas", {
+    type: "boolean",
+    description: "Generate schemas/models without interactive prompts",
+  })
+  .option("schemaFormat", {
+    type: "string",
+    choices: ["zod", "json", "pydantic", "both", "all"],
+    description: "Schema format: zod, json, pydantic, both (zod+json), or all",
+  })
+  .option("schemaOutDir", {
+    type: "string",
+    description: "Output directory for generated schemas (absolute path respected)",
+  })
   .option("migrateCollectionsToTables", {
     alias: ["migrate-collections"],
     type: "boolean",

package/src/migrations/appwriteToX.ts

@@ -638,7 +638,7 @@ export class AppwriteToX {
       }
 
       MessageFormatter.info("Generating Zod schemas from synced collections...", { prefix: "Migration" });
-      generator.generateSchemas();
+      await generator.generateSchemas();
       MessageFormatter.success("Sync-from-Appwrite process completed successfully", { prefix: "Migration" });
     } catch (error) {
       MessageFormatter.error(

package/src/migrations/yaml/generateImportSchemas.ts

@@ -562,12 +562,12 @@ export function generateTableSchema(): any {
   // Add column definition (similar to attribute but with table terminology)
   tableSchema.$defs.column = JSON.parse(JSON.stringify(tableSchema.$defs.attribute));
 
-  // Add encrypted property (table-specific feature)
-  tableSchema.$defs.column.properties.encrypted = {
-    "type": "boolean",
-    "description": "Whether the column should be encrypted",
-    "default": false
-  };
+  // Add encrypt property (table-specific feature)
+  tableSchema.$defs.column.properties.encrypt = {
+    "type": "boolean",
+    "description": "Whether the column should be encrypted",
+    "default": false
+  };
 
   // Replace relatedCollection with relatedTable for table terminology
   delete tableSchema.$defs.column.properties.relatedCollection;
@@ -1351,4 +1351,4 @@ options:
     fs.writeFileSync(examplePath, example.content);
     logger.info(`Created import example: ${examplePath}`);
   }
-}
+}

package/src/setupCommands.ts

@@ -328,6 +328,12 @@ export function createYamlValidationSchema(
               "default": false,
               "description": `Whether the ${useTables ? 'column' : 'attribute'} is an array`
             },
+            // Encryption flag for string types
+            "encrypt": {
+              "type": "boolean",
+              "default": false,
+              "description": `Enable encryption for string ${useTables ? 'columns' : 'attributes'}`
+            },
             ...(useTables ? {
               "unique": {
                 "type": "boolean",

package/src/shared/attributeMapper.ts

@@ -20,7 +20,7 @@ export function mapToCreateAttributeParams(
   const required = !!(attr as any).required;
   const array = !!(attr as any).array;
   const xdefault = (attr as any).xdefault;
-  const encrypt = (attr as any).encrypted ?? (attr as any).encrypt;
+  const encrypt = (attr as any).encrypt;
 
   // Numeric helpers
   const rawMin = ensureNumber((attr as any).min);
@@ -184,7 +184,7 @@ export function mapToUpdateAttributeParams(
   }
   setIfDefined("array", (attr as any).array);
   // encrypt only applies to string types
-  if (type === "string") setIfDefined("encrypt", (attr as any).encrypted ?? (attr as any).encrypt);
+  if (type === "string") setIfDefined("encrypt", (attr as any).encrypt);
 
   // Numeric normalization
   const toNum = (n: any) => (n === null || n === undefined ? undefined : (Number(n)));

package/src/shared/jsonSchemaGenerator.ts

@@ -236,7 +236,7 @@ export class JsonSchemaGenerator {
     outputDirectory?: string;
     verbose?: boolean;
   } = {}): void {
-    const { outputFormat = "both", outputDirectory = "schemas", verbose = false } = options;
+    const { outputFormat = "both", outputDirectory = "schemas", verbose = false } = options;
 
     if (!this.config.collections) {
       if (verbose) {
@@ -246,7 +246,9 @@ export class JsonSchemaGenerator {
     }
 
     // Create JSON schemas directory using provided outputDirectory
-    const jsonSchemasPath = path.join(this.appwriteFolderPath, outputDirectory);
+    const jsonSchemasPath = path.isAbsolute(outputDirectory)
+      ? outputDirectory
+      : path.join(this.appwriteFolderPath, outputDirectory);
     if (!fs.existsSync(jsonSchemasPath)) {
       fs.mkdirSync(jsonSchemasPath, { recursive: true });
     }