appwrite-utils-cli 1.8.3 → 1.8.5

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

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();

package/dist/main.js

@@ -407,6 +407,23 @@ const argv = yargs(hideBin(process.argv))
     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"],

package/dist/migrations/appwriteToX.js

@@ -468,7 +468,7 @@ export class AppwriteToX {
                 await generator.updateConfig(configWithApiContext, false);
             }
             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) {

package/dist/migrations/yaml/generateImportSchemas.js

@@ -551,8 +551,8 @@ export function generateTableSchema() {
     }
     // 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 = {
+    // Add encrypt property (table-specific feature)
+    tableSchema.$defs.column.properties.encrypt = {
         "type": "boolean",
         "description": "Whether the column should be encrypted",
         "default": false

package/dist/setupCommands.js

@@ -259,6 +259,12 @@ export function createYamlValidationSchema(yamlSchemaFolder, useTables) {
                             "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/dist/shared/attributeMapper.js

@@ -14,7 +14,7 @@ export function mapToCreateAttributeParams(attr, base) {
     const required = !!attr.required;
     const array = !!attr.array;
     const xdefault = attr.xdefault;
-    const encrypt = attr.encrypted ?? attr.encrypt;
+    const encrypt = attr.encrypt;
     // Numeric helpers
     const rawMin = ensureNumber(attr.min);
     const rawMax = ensureNumber(attr.max);
@@ -160,7 +160,7 @@ export function mapToUpdateAttributeParams(attr, base) {
     setIfDefined("array", attr.array);
     // encrypt only applies to string types
     if (type === "string")
-        setIfDefined("encrypt", attr.encrypted ?? attr.encrypt);
+        setIfDefined("encrypt", attr.encrypt);
     // Numeric normalization
     const toNum = (n) => (n === null || n === undefined ? undefined : (Number(n)));
     let min = toNum(attr.min);

package/dist/shared/jsonSchemaGenerator.js

@@ -177,7 +177,9 @@ export class JsonSchemaGenerator {
             return;
         }
         // 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 });
         }

package/dist/shared/pydanticModelGenerator.d.ts

@@ -0,0 +1,17 @@
+import type { AppwriteConfig } from 'appwrite-utils';
+export declare class PydanticModelGenerator {
+    private config;
+    private appwriteFolderPath;
+    constructor(config: AppwriteConfig, appwriteFolderPath: string);
+    generatePydanticModels(options: {
+        baseOutputDirectory: string;
+        verbose?: boolean;
+    }): void;
+    private writeBase;
+    private generateModel;
+    private composeHeader;
+    private defaultInitializer;
+    private mapAttributeToPythonType;
+    private toSnake;
+    private toPascal;
+}