appwrite-utils-cli 1.7.7 → 1.7.8

package/dist/shared/selectionDialogs.js

@@ -0,0 +1,516 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { MessageFormatter } from "./messageFormatter.js";
+import { logger } from "./logging.js";
+/**
+ * Comprehensive selection dialog system for enhanced sync flow
+ *
+ * This class provides interactive dialogs for selecting databases, tables/collections,
+ * and storage buckets during sync operations. It supports both new and existing
+ * configurations with visual indicators and comprehensive confirmation flows.
+ *
+ * @example
+ * ```typescript
+ * import { SelectionDialogs } from './shared/selectionDialogs.js';
+ * import type { Models } from 'node-appwrite';
+ *
+ * // Example usage in a sync command
+ * const availableDatabases: Models.Database[] = await getAvailableDatabases();
+ * const configuredDatabases = config.databases || [];
+ *
+ * // Prompt about existing configuration
+ * const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+ *
+ * if (modifyConfiguration) {
+ *   // Select databases
+ *   const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+ *     availableDatabases,
+ *     configuredDatabases,
+ *     { showSelectAll: true, allowNewOnly: !syncExisting }
+ *   );
+ *
+ *   // For each database, select tables
+ *   const tableSelectionsMap = new Map<string, string[]>();
+ *   const availableTablesMap = new Map<string, any[]>();
+ *
+ *   for (const databaseId of selectedDatabaseIds) {
+ *     const database = availableDatabases.find(db => db.$id === databaseId)!;
+ *     const availableTables = await getTablesForDatabase(databaseId);
+ *     const configuredTables = getConfiguredTablesForDatabase(databaseId);
+ *
+ *     availableTablesMap.set(databaseId, availableTables);
+ *
+ *     const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+ *       databaseId,
+ *       database.name,
+ *       availableTables,
+ *       configuredTables,
+ *       { showSelectAll: true, allowNewOnly: !syncExisting }
+ *     );
+ *
+ *     tableSelectionsMap.set(databaseId, selectedTableIds);
+ *   }
+ *
+ *   // Select buckets
+ *   const availableBuckets = await getAvailableBuckets();
+ *   const configuredBuckets = config.buckets || [];
+ *   const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+ *     selectedDatabaseIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     { showSelectAll: true, groupByDatabase: true }
+ *   );
+ *
+ *   // Create selection objects
+ *   const databaseSelections = SelectionDialogs.createDatabaseSelection(
+ *     selectedDatabaseIds,
+ *     availableDatabases,
+ *     tableSelectionsMap,
+ *     configuredDatabases,
+ *     availableTablesMap
+ *   );
+ *
+ *   const bucketSelections = SelectionDialogs.createBucketSelection(
+ *     selectedBucketIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     availableDatabases
+ *   );
+ *
+ *   // Show final confirmation
+ *   const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+ *     databaseSelections,
+ *     bucketSelections
+ *   );
+ *
+ *   const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+ *
+ *   if (confirmed) {
+ *     // Proceed with sync operation
+ *     await performSync(databaseSelections, bucketSelections);
+ *   }
+ * }
+ * ```
+ */
+export class SelectionDialogs {
+    /**
+     * Prompts user about existing configuration
+     */
+    static async promptForExistingConfig(configuredItems) {
+        if (configuredItems.length === 0) {
+            return { syncExisting: false, modifyConfiguration: true };
+        }
+        MessageFormatter.section("Existing Configuration Found");
+        MessageFormatter.info(`Found ${configuredItems.length} configured items.`, { skipLogging: true });
+        const { syncExisting } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'syncExisting',
+                message: 'Sync existing configured items?',
+                default: true
+            }]);
+        if (!syncExisting) {
+            return { syncExisting: false, modifyConfiguration: true };
+        }
+        const { modifyConfiguration } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'modifyConfiguration',
+                message: 'Add/remove items from configuration?',
+                default: false
+            }]);
+        return { syncExisting, modifyConfiguration };
+    }
+    /**
+     * Shows database selection dialog with indicators for configured vs new databases
+     */
+    static async selectDatabases(availableDatabases, configuredDatabases, options = {}) {
+        const { showSelectAll = true, allowNewOnly = false, defaultSelected = [] } = options;
+        MessageFormatter.section("Database Selection");
+        const configuredIds = new Set(configuredDatabases.map(db => db.$id || db.id));
+        let choices = [];
+        if (showSelectAll && availableDatabases.length > 1) {
+            choices.push({
+                name: chalk.green.bold('📋 Select All Databases'),
+                value: '__SELECT_ALL__',
+                short: 'All databases'
+            });
+        }
+        availableDatabases.forEach(database => {
+            const isConfigured = configuredIds.has(database.$id);
+            const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+            const name = `${status} ${database.name} (${database.$id})`;
+            if (allowNewOnly && isConfigured) {
+                return; // Skip configured databases if only allowing new ones
+            }
+            choices.push({
+                name,
+                value: database.$id,
+                short: database.name,
+                checked: defaultSelected.includes(database.$id) || (!allowNewOnly && isConfigured)
+            });
+        });
+        if (choices.length === 0) {
+            MessageFormatter.warning("No databases available for selection.", { skipLogging: true });
+            return [];
+        }
+        const { selectedDatabaseIds } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedDatabaseIds',
+                message: 'Select databases to sync:',
+                choices,
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return chalk.red('Please select at least one database.');
+                    }
+                    if (input.includes('__SELECT_ALL__') && input.length > 1) {
+                        return chalk.red('Cannot select "Select All" with individual databases.');
+                    }
+                    return true;
+                }
+            }]);
+        // Handle select all
+        if (selectedDatabaseIds.includes('__SELECT_ALL__')) {
+            const allIds = availableDatabases.map(db => db.$id);
+            if (allowNewOnly) {
+                return allIds.filter(id => !configuredIds.has(id));
+            }
+            return allIds;
+        }
+        return selectedDatabaseIds;
+    }
+    /**
+     * Shows table/collection selection dialog for a specific database
+     */
+    static async selectTablesForDatabase(databaseId, databaseName, availableTables, configuredTables, options = {}) {
+        const { showSelectAll = true, allowNewOnly = false, defaultSelected = [], showDatabaseContext = true } = options;
+        if (showDatabaseContext) {
+            MessageFormatter.section(`Table Selection for ${databaseName}`);
+        }
+        const configuredIds = new Set(configuredTables.map(table => table.$id || table.id));
+        let choices = [];
+        if (showSelectAll && availableTables.length > 1) {
+            choices.push({
+                name: chalk.green.bold('📋 Select All Tables'),
+                value: '__SELECT_ALL__',
+                short: 'All tables'
+            });
+        }
+        availableTables.forEach(table => {
+            const isConfigured = configuredIds.has(table.$id);
+            const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+            const name = `${status} ${table.name} (${table.$id})`;
+            if (allowNewOnly && isConfigured) {
+                return; // Skip configured tables if only allowing new ones
+            }
+            choices.push({
+                name,
+                value: table.$id,
+                short: table.name,
+                checked: defaultSelected.includes(table.$id) || (!allowNewOnly && isConfigured)
+            });
+        });
+        if (choices.length === 0) {
+            MessageFormatter.warning(`No tables available for database: ${databaseName}`, { skipLogging: true });
+            return [];
+        }
+        const { selectedTableIds } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedTableIds',
+                message: `Select tables to sync for ${databaseName}:`,
+                choices,
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return chalk.red('Please select at least one table.');
+                    }
+                    if (input.includes('__SELECT_ALL__') && input.length > 1) {
+                        return chalk.red('Cannot select "Select All" with individual tables.');
+                    }
+                    return true;
+                }
+            }]);
+        // Handle select all
+        if (selectedTableIds.includes('__SELECT_ALL__')) {
+            const allIds = availableTables.map(table => table.$id);
+            if (allowNewOnly) {
+                return allIds.filter(id => !configuredIds.has(id));
+            }
+            return allIds;
+        }
+        return selectedTableIds;
+    }
+    /**
+     * Shows bucket selection dialog for selected databases
+     */
+    static async selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, options = {}) {
+        const { showSelectAll = true, allowNewOnly = false, defaultSelected = [], groupByDatabase = true } = options;
+        MessageFormatter.section("Storage Bucket Selection");
+        const configuredIds = new Set(configuredBuckets.map(bucket => bucket.$id || bucket.id));
+        // Filter buckets that are associated with selected databases
+        const relevantBuckets = availableBuckets.filter(bucket => {
+            if (selectedDatabaseIds.length === 0)
+                return true; // If no databases selected, show all buckets
+            return selectedDatabaseIds.includes(bucket.databaseId) || !bucket.databaseId;
+        });
+        if (relevantBuckets.length === 0) {
+            MessageFormatter.warning("No storage buckets available for selected databases.", { skipLogging: true });
+            return [];
+        }
+        let choices = [];
+        if (showSelectAll && relevantBuckets.length > 1) {
+            choices.push({
+                name: chalk.green.bold('📋 Select All Buckets'),
+                value: '__SELECT_ALL__',
+                short: 'All buckets'
+            });
+        }
+        if (groupByDatabase) {
+            // Group buckets by database
+            const bucketsByDatabase = new Map();
+            relevantBuckets.forEach(bucket => {
+                const dbId = bucket.databaseId || 'ungrouped';
+                if (!bucketsByDatabase.has(dbId)) {
+                    bucketsByDatabase.set(dbId, []);
+                }
+                bucketsByDatabase.get(dbId).push(bucket);
+            });
+            // Add buckets grouped by database
+            selectedDatabaseIds.forEach(dbId => {
+                const buckets = bucketsByDatabase.get(dbId) || [];
+                if (buckets.length > 0) {
+                    choices.push(new inquirer.Separator(chalk.cyan(`📁 Database: ${dbId}`)));
+                    buckets.forEach(bucket => {
+                        const isConfigured = configuredIds.has(bucket.$id);
+                        const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+                        const name = `${status} ${bucket.name} (${bucket.$id})`;
+                        if (allowNewOnly && isConfigured) {
+                            return; // Skip configured buckets if only allowing new ones
+                        }
+                        choices.push({
+                            name: `  ${name}`,
+                            value: bucket.$id,
+                            short: bucket.name,
+                            checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+                        });
+                    });
+                }
+            });
+            // Add ungrouped buckets
+            const ungroupedBuckets = bucketsByDatabase.get('ungrouped') || [];
+            if (ungroupedBuckets.length > 0) {
+                choices.push(new inquirer.Separator(chalk.cyan('📁 General Storage')));
+                ungroupedBuckets.forEach(bucket => {
+                    const isConfigured = configuredIds.has(bucket.$id);
+                    const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+                    const name = `${status} ${bucket.name} (${bucket.$id})`;
+                    if (allowNewOnly && isConfigured) {
+                        return; // Skip configured buckets if only allowing new ones
+                    }
+                    choices.push({
+                        name: `  ${name}`,
+                        value: bucket.$id,
+                        short: bucket.name,
+                        checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+                    });
+                });
+            }
+        }
+        else {
+            // Flat list of buckets
+            relevantBuckets.forEach(bucket => {
+                const isConfigured = configuredIds.has(bucket.$id);
+                const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+                const dbContext = bucket.databaseId ? ` [${bucket.databaseId}]` : '';
+                const name = `${status} ${bucket.name} (${bucket.$id})${dbContext}`;
+                if (allowNewOnly && isConfigured) {
+                    return; // Skip configured buckets if only allowing new ones
+                }
+                choices.push({
+                    name,
+                    value: bucket.$id,
+                    short: bucket.name,
+                    checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+                });
+            });
+        }
+        const { selectedBucketIds } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedBucketIds',
+                message: 'Select storage buckets to sync:',
+                choices,
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return chalk.yellow('No storage buckets selected. Continue with databases only?') || true;
+                    }
+                    if (input.includes('__SELECT_ALL__') && input.length > 1) {
+                        return chalk.red('Cannot select "Select All" with individual buckets.');
+                    }
+                    return true;
+                }
+            }]);
+        // Handle select all
+        if (selectedBucketIds && selectedBucketIds.includes('__SELECT_ALL__')) {
+            const allIds = relevantBuckets.map(bucket => bucket.$id);
+            if (allowNewOnly) {
+                return allIds.filter(id => !configuredIds.has(id));
+            }
+            return allIds;
+        }
+        return selectedBucketIds || [];
+    }
+    /**
+     * Shows final confirmation dialog with sync selection summary
+     */
+    static async confirmSyncSelection(selectionSummary) {
+        MessageFormatter.banner("Sync Selection Summary", "Review your selections before proceeding");
+        // Database summary
+        console.log(chalk.bold.cyan("\n📊 Databases:"));
+        console.log(`  Total: ${selectionSummary.totalDatabases}`);
+        console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.databases}`);
+        console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.databases}`);
+        if (selectionSummary.databases.length > 0) {
+            console.log(chalk.gray("\n  Selected databases:"));
+            selectionSummary.databases.forEach(db => {
+                const status = db.isNew ? chalk.blue('○') : chalk.green('✅');
+                console.log(`    ${status} ${db.databaseName} (${db.tableNames.length} tables)`);
+            });
+        }
+        // Table summary
+        console.log(chalk.bold.cyan("\n📋 Tables/Collections:"));
+        console.log(`  Total: ${selectionSummary.totalTables}`);
+        console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.tables}`);
+        console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.tables}`);
+        // Bucket summary
+        console.log(chalk.bold.cyan("\n🪣 Storage Buckets:"));
+        console.log(`  Total: ${selectionSummary.totalBuckets}`);
+        console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.buckets}`);
+        console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.buckets}`);
+        if (selectionSummary.buckets.length > 0) {
+            console.log(chalk.gray("\n  Selected buckets:"));
+            selectionSummary.buckets.forEach(bucket => {
+                const status = bucket.isNew ? chalk.blue('○') : chalk.green('✅');
+                const dbContext = bucket.databaseName ? ` [${bucket.databaseName}]` : '';
+                console.log(`    ${status} ${bucket.bucketName}${dbContext}`);
+            });
+        }
+        console.log(); // Add spacing
+        const { confirmed } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'confirmed',
+                message: chalk.green.bold('Proceed with sync operation?'),
+                default: true
+            }]);
+        if (confirmed) {
+            MessageFormatter.success("Sync operation confirmed.", { skipLogging: true });
+            logger.info("Sync selection confirmed", {
+                databases: selectionSummary.totalDatabases,
+                tables: selectionSummary.totalTables,
+                buckets: selectionSummary.totalBuckets
+            });
+        }
+        else {
+            MessageFormatter.warning("Sync operation cancelled.", { skipLogging: true });
+            logger.info("Sync selection cancelled by user");
+        }
+        return confirmed;
+    }
+    /**
+     * Creates a sync selection summary from selected items
+     */
+    static createSyncSelectionSummary(databaseSelections, bucketSelections) {
+        const totalDatabases = databaseSelections.length;
+        const totalTables = databaseSelections.reduce((sum, db) => sum + db.tableIds.length, 0);
+        const totalBuckets = bucketSelections.length;
+        const newDatabases = databaseSelections.filter(db => db.isNew).length;
+        const newTables = databaseSelections.reduce((sum, db) => sum + db.tableIds.length, 0); // TODO: Track which tables are new
+        const newBuckets = bucketSelections.filter(bucket => bucket.isNew).length;
+        const existingDatabases = totalDatabases - newDatabases;
+        const existingTables = totalTables - newTables;
+        const existingBuckets = totalBuckets - newBuckets;
+        return {
+            databases: databaseSelections,
+            buckets: bucketSelections,
+            totalDatabases,
+            totalTables,
+            totalBuckets,
+            newItems: {
+                databases: newDatabases,
+                tables: newTables,
+                buckets: newBuckets
+            },
+            existingItems: {
+                databases: existingDatabases,
+                tables: existingTables,
+                buckets: existingBuckets
+            }
+        };
+    }
+    /**
+     * Helper method to create database selection objects
+     */
+    static createDatabaseSelection(selectedDatabaseIds, availableDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap = new Map()) {
+        const configuredIds = new Set(configuredDatabases.map(db => db.$id || db.id));
+        return selectedDatabaseIds.map(databaseId => {
+            const database = availableDatabases.find(db => db.$id === databaseId);
+            if (!database) {
+                throw new Error(`Database with ID ${databaseId} not found in available databases`);
+            }
+            const tableIds = tableSelectionsMap.get(databaseId) || [];
+            const tables = availableTablesMap.get(databaseId) || [];
+            const tableNames = tables.map(table => table.name || table.$id || `Table-${table.$id}`);
+            return {
+                databaseId,
+                databaseName: database.name,
+                tableIds,
+                tableNames,
+                isNew: !configuredIds.has(databaseId)
+            };
+        });
+    }
+    /**
+     * Helper method to create bucket selection objects
+     */
+    static createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, availableDatabases) {
+        const configuredIds = new Set(configuredBuckets.map(bucket => bucket.$id || bucket.id));
+        return selectedBucketIds.map(bucketId => {
+            const bucket = availableBuckets.find(b => b.$id === bucketId);
+            if (!bucket) {
+                throw new Error(`Bucket with ID ${bucketId} not found in available buckets`);
+            }
+            const database = bucket.databaseId ?
+                availableDatabases.find(db => db.$id === bucket.databaseId) : undefined;
+            return {
+                bucketId,
+                bucketName: bucket.name,
+                databaseId: bucket.databaseId,
+                databaseName: database?.name,
+                isNew: !configuredIds.has(bucketId)
+            };
+        });
+    }
+    /**
+     * Shows a progress message during selection operations
+     */
+    static showProgress(message) {
+        MessageFormatter.progress(message, { skipLogging: true });
+    }
+    /**
+     * Shows an error message and handles graceful cancellation
+     */
+    static showError(message, error) {
+        MessageFormatter.error(message, error, { skipLogging: true });
+        logger.error(`Selection dialog error: ${message}`, { error: error?.message });
+    }
+    /**
+     * Shows a warning message
+     */
+    static showWarning(message) {
+        MessageFormatter.warning(message, { skipLogging: true });
+        logger.warn(`Selection dialog warning: ${message}`);
+    }
+    /**
+     * Shows a success message
+     */
+    static showSuccess(message) {
+        MessageFormatter.success(message, { skipLogging: true });
+        logger.info(`Selection dialog success: ${message}`);
+    }
+}

package/dist/utils/configDiscovery.d.ts

@@ -27,11 +27,11 @@ export declare const findFunctionsDir: (dir: string, depth?: number) => string |
  */
 export declare const loadYamlCollection: (filePath: string) => CollectionCreate | null;
 /**
- * Loads a YAML table file and converts it to table format
+ * Loads a YAML table file and converts it to CollectionCreate format
  * @param filePath Path to the YAML table file
- * @returns Table object or null if loading fails
+ * @returns CollectionCreate object or null if loading fails
  */
-export declare const loadYamlTable: (filePath: string) => any | null;
+export declare const loadYamlTable: (filePath: string) => CollectionCreate | null;
 /**
  * Result of discovering collections from a directory
  */
@@ -54,7 +54,7 @@ export declare const discoverCollections: (collectionsDir: string) => Promise<Co
  * Result of discovering tables from a directory
  */
 export interface TableDiscoveryResult {
-    tables: any[];
+    tables: CollectionCreate[];
     loadedNames: Set<string>;
     conflicts: Array<{
         name: string;

package/dist/utils/configDiscovery.js

@@ -135,6 +135,45 @@ const YamlCollectionSchema = z.object({
     })).optional().default([]),
     importDefs: z.array(z.any()).optional().default([])
 });
+// YAML Table Schema - Supports table-specific terminology
+const YamlTableSchema = z.object({
+    name: z.string(),
+    id: z.string().optional(),
+    rowSecurity: z.boolean().default(false), // Tables use rowSecurity
+    enabled: z.boolean().default(true),
+    permissions: z.array(z.object({
+        permission: z.string(),
+        target: z.string()
+    })).optional().default([]),
+    columns: z.array(// Tables use columns terminology
+    z.object({
+        key: z.string(),
+        type: z.string(),
+        size: z.number().optional(),
+        required: z.boolean().default(false),
+        array: z.boolean().optional(),
+        encrypted: z.boolean().optional(), // Tables support encrypted property
+        default: z.any().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+        elements: z.array(z.string()).optional(),
+        relatedTable: z.string().optional(), // Tables use relatedTable
+        relationType: z.string().optional(),
+        twoWay: z.boolean().optional(),
+        twoWayKey: z.string().optional(),
+        onDelete: z.string().optional(),
+        side: z.string().optional(),
+        encrypt: z.boolean().optional(),
+        format: z.string().optional()
+    })).optional().default([]),
+    indexes: z.array(z.object({
+        key: z.string(),
+        type: z.string(),
+        columns: z.array(z.string()), // Tables use columns in indexes
+        orders: z.array(z.string()).optional()
+    })).optional().default([]),
+    importDefs: z.array(z.any()).optional().default([])
+});
 /**
  * Loads a YAML collection file and converts it to CollectionCreate format
  * @param filePath Path to the YAML collection file
@@ -190,55 +229,52 @@ export const loadYamlCollection = (filePath) => {
     }
 };
 /**
- * Loads a YAML table file and converts it to table format
+ * Loads a YAML table file and converts it to CollectionCreate format
  * @param filePath Path to the YAML table file
- * @returns Table object or null if loading fails
+ * @returns CollectionCreate object or null if loading fails
  */
 export const loadYamlTable = (filePath) => {
     try {
         const fileContent = fs.readFileSync(filePath, "utf8");
         const yamlData = yaml.load(fileContent);
-        // For now, use the collection schema as base and adapt for tables
-        const parsedTable = YamlCollectionSchema.parse(yamlData);
-        // Convert YAML table to TableCreate format
+        // Use the new table-specific schema
+        const parsedTable = YamlTableSchema.parse(yamlData);
+        // Convert YAML table to CollectionCreate format (internal representation)
         const table = {
             name: parsedTable.name,
-            tableId: yamlData.tableId || parsedTable.id || parsedTable.name.toLowerCase().replace(/\s+/g, '_'),
-            documentSecurity: parsedTable.documentSecurity,
+            $id: yamlData.tableId || parsedTable.id || parsedTable.name.toLowerCase().replace(/\s+/g, '_'),
+            documentSecurity: parsedTable.rowSecurity, // Convert rowSecurity to documentSecurity
             enabled: parsedTable.enabled,
             $permissions: parsedTable.permissions.map(p => ({
                 permission: p.permission,
                 target: p.target
             })),
-            attributes: parsedTable.attributes.map(attr => ({
-                key: attr.key,
-                type: attr.type,
-                size: attr.size,
-                required: attr.required,
-                array: attr.array,
-                xdefault: attr.default,
-                min: attr.min,
-                max: attr.max,
-                elements: attr.elements,
-                relatedCollection: attr.relatedCollection,
-                relationType: attr.relationType,
-                twoWay: attr.twoWay,
-                twoWayKey: attr.twoWayKey,
-                onDelete: attr.onDelete,
-                side: attr.side,
-                encrypted: attr.encrypt,
-                format: attr.format
+            attributes: parsedTable.columns.map(col => ({
+                key: col.key,
+                type: col.type,
+                size: col.size,
+                required: col.required,
+                array: col.array,
+                xdefault: col.default,
+                min: col.min,
+                max: col.max,
+                elements: col.elements,
+                relatedCollection: col.relatedTable, // Convert relatedTable to relatedCollection
+                relationType: col.relationType,
+                twoWay: col.twoWay,
+                twoWayKey: col.twoWayKey,
+                onDelete: col.onDelete,
+                side: col.side,
+                encrypted: col.encrypted || col.encrypt, // Support both encrypted and encrypt
+                format: col.format
             })),
             indexes: parsedTable.indexes.map(idx => ({
                 key: idx.key,
                 type: idx.type,
-                attributes: idx.attributes,
+                attributes: idx.columns, // Convert columns to attributes
                 orders: idx.orders
             })),
-            importDefs: parsedTable.importDefs,
-            databaseId: yamlData.databaseId,
-            // Add backward compatibility field
-            $id: yamlData.$id || parsedTable.id
+            importDefs: parsedTable.importDefs || []
         };
         return table;
     }

package/dist/utils/yamlConverter.d.ts

@@ -3,6 +3,7 @@ export interface YamlCollectionData {
     name: string;
     id?: string;
     documentSecurity?: boolean;
+    rowSecurity?: boolean;
     enabled?: boolean;
     permissions?: Array<{
         permission: string;