appwrite-utils-cli 1.7.7 → 1.7.8

package/src/utils/configDiscovery.ts

@@ -157,6 +157,53 @@ const YamlCollectionSchema = z.object({
 
 type YamlCollection = z.infer<typeof YamlCollectionSchema>;
 
+// 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([])
+});
+
+type YamlTable = z.infer<typeof YamlTableSchema>;
+
 /**
  * Loads a YAML collection file and converts it to CollectionCreate format
  * @param filePath Path to the YAML collection file
@@ -214,57 +261,54 @@ export 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 const loadYamlTable = (filePath: string): any | null => {
+export const loadYamlTable = (filePath: string): CollectionCreate | null => {
   try {
     const fileContent = fs.readFileSync(filePath, "utf8");
     const yamlData = yaml.load(fileContent) as unknown;
 
-    // For now, use the collection schema as base and adapt for tables
-    const parsedTable = YamlCollectionSchema.parse(yamlData);
+    // Use the new table-specific schema
+    const parsedTable = YamlTableSchema.parse(yamlData);
 
-    // Convert YAML table to TableCreate format
-    const table: any = {
+    // Convert YAML table to CollectionCreate format (internal representation)
+    const table: CollectionCreate = {
       name: parsedTable.name,
-      tableId: (yamlData as any).tableId || parsedTable.id || parsedTable.name.toLowerCase().replace(/\s+/g, '_'),
-      documentSecurity: parsedTable.documentSecurity,
+      $id: (yamlData as any).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 as any,
         target: p.target
       })),
-      attributes: parsedTable.attributes.map(attr => ({
-        key: attr.key,
-        type: attr.type as any,
-        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 as any,
-        twoWay: attr.twoWay,
-        twoWayKey: attr.twoWayKey,
-        onDelete: attr.onDelete as any,
-        side: attr.side as any,
-        encrypted: (attr as any).encrypt,
-        format: (attr as any).format
+      attributes: parsedTable.columns.map(col => ({ // Convert columns to attributes
+        key: col.key,
+        type: col.type as any,
+        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 as any,
+        twoWay: col.twoWay,
+        twoWayKey: col.twoWayKey,
+        onDelete: col.onDelete as any,
+        side: col.side as any,
+        encrypted: col.encrypted || col.encrypt, // Support both encrypted and encrypt
+        format: col.format
       })),
       indexes: parsedTable.indexes.map(idx => ({
         key: idx.key,
         type: idx.type as any,
-        attributes: idx.attributes,
+        attributes: idx.columns, // Convert columns to attributes
         orders: idx.orders as any
       })),
-      importDefs: parsedTable.importDefs,
-      databaseId: (yamlData as any).databaseId,
-      // Add backward compatibility field
-      $id: (yamlData as any).$id || parsedTable.id
+      importDefs: parsedTable.importDefs || []
     };
 
     return table;
@@ -346,7 +390,7 @@ export const discoverCollections = async (collectionsDir: string): Promise<Colle
  * Result of discovering tables from a directory
  */
 export interface TableDiscoveryResult {
-  tables: any[];
+  tables: CollectionCreate[];
   loadedNames: Set<string>;
   conflicts: Array<{ name: string; source1: string; source2: string }>;
 }
@@ -361,7 +405,7 @@ export const discoverTables = async (
   tablesDir: string,
   existingNames: Set<string> = new Set()
 ): Promise<TableDiscoveryResult> => {
-  const tables: any[] = [];
+  const tables: CollectionCreate[] = [];
   const loadedNames = new Set<string>();
   const conflicts: Array<{ name: string; source1: string; source2: string }> = [];
 
@@ -380,7 +424,7 @@ export const discoverTables = async (
         continue;
       }
       const filePath = path.join(tablesDir, file);
-      let table: any | null = null;
+      let table: CollectionCreate | null = null;
 
       // Handle YAML tables
       if (file.endsWith('.yaml') || file.endsWith('.yml')) {
@@ -391,7 +435,7 @@ export const discoverTables = async (
       else if (file.endsWith('.ts')) {
         const fileUrl = pathToFileURL(filePath).href;
         const tableModule = (await import(fileUrl));
-        const importedTable: any = tableModule.default?.default || tableModule.default || tableModule;
+        const importedTable: CollectionCreate = tableModule.default?.default || tableModule.default || tableModule;
         if (importedTable) {
           table = importedTable;
           // Ensure importDefs are properly loaded
@@ -402,7 +446,7 @@ export const discoverTables = async (
       }
 
       if (table) {
-        const tableName = table.name || table.tableId || table.$id || file;
+        const tableName = table.name || (table as any).tableId || table.$id || file;
 
         // Check for naming conflicts with existing collections
         if (existingNames.has(tableName)) {
@@ -415,7 +459,7 @@ export const discoverTables = async (
         } else {
           loadedNames.add(tableName);
           // Mark as coming from tables directory
-          table._isFromTablesDir = true;
+          (table as any)._isFromTablesDir = true;
           tables.push(table);
         }
       }
@@ -467,7 +511,7 @@ export const discoverLegacyDirectory = async (
               ...collection,
               _isFromTablesDir: true,
               tableId: collection.$id || collection.name.toLowerCase().replace(/\s+/g, '_')
-            };
+            } as CollectionCreate;
             items.push(table);
           } else {
             items.push(collection);

package/src/utils/yamlConverter.ts

@@ -8,6 +8,7 @@ export interface YamlCollectionData {
   name: string;
   id?: string;
   documentSecurity?: boolean;
+  rowSecurity?: boolean;
   enabled?: boolean;
   permissions?: Array<{
     permission: string;
@@ -86,10 +87,16 @@ export function collectionToYaml(
   const yamlData: YamlCollectionData = {
     name: collection.name,
     id: collection.$id,
-    documentSecurity: collection.documentSecurity,
     enabled: collection.enabled,
   };
 
+  // Use appropriate security field based on terminology
+  if (config.useTableTerminology) {
+    yamlData.rowSecurity = collection.documentSecurity;
+  } else {
+    yamlData.documentSecurity = collection.documentSecurity;
+  }
+
   // Convert permissions
   if (collection.$permissions && collection.$permissions.length > 0) {
     yamlData.permissions = collection.$permissions.map(p => ({
@@ -240,6 +247,12 @@ export function normalizeYamlData(yamlData: YamlCollectionData): YamlCollectionD
     }));
   }
 
+  // Normalize security fields - prefer documentSecurity for consistency
+  if (yamlData.rowSecurity !== undefined && yamlData.documentSecurity === undefined) {
+    normalized.documentSecurity = yamlData.rowSecurity;
+    delete normalized.rowSecurity;
+  }
+
   return normalized;
 }
 
@@ -248,7 +261,8 @@ export function normalizeYamlData(yamlData: YamlCollectionData): YamlCollectionD
  */
 export function usesTableTerminology(yamlData: YamlCollectionData): boolean {
   return !!(yamlData.columns && yamlData.columns.length > 0) ||
-         !!(yamlData.indexes?.some(idx => !!(idx as any).columns));
+         !!(yamlData.indexes?.some(idx => !!(idx as any).columns)) ||
+         yamlData.rowSecurity !== undefined;
 }
 
 /**
@@ -279,6 +293,12 @@ export function convertTerminology(
       }));
     }
 
+    // Convert security field
+    if (yamlData.documentSecurity !== undefined && yamlData.rowSecurity === undefined) {
+      converted.rowSecurity = yamlData.documentSecurity;
+      delete converted.documentSecurity;
+    }
+
     return converted;
   } else {
     // Convert columns to attributes (normalize)
@@ -367,7 +387,6 @@ export function generateYamlTemplate(
   const template: YamlCollectionData = {
     name: entityName,
     id: entityName.toLowerCase().replace(/\s+/g, '_'),
-    documentSecurity: false,
     enabled: true,
     permissions: [
       {
@@ -390,6 +409,13 @@ export function generateYamlTemplate(
     importDefs: []
   };
 
+  // Use appropriate security field based on terminology
+  if (config.useTableTerminology) {
+    template.rowSecurity = false;
+  } else {
+    template.documentSecurity = false;
+  }
+
   // Assign fields with correct property name
   (template as any)[fieldsKey] = fieldsArray;
   template.indexes = indexesArray as any;

package/src/utilsController.ts

@@ -72,6 +72,7 @@ import { configureLogging, updateLogger, logger } from "./shared/logging.js";
 import { MessageFormatter, Messages } from "./shared/messageFormatter.js";
 import { SchemaGenerator } from "./shared/schemaGenerator.js";
 import { findYamlConfig } from "./config/yamlConfig.js";
+import { createImportSchemas } from "./migrations/yaml/generateImportSchemas.js";
 import {
   validateCollectionsTablesConfig,
   reportValidationResults,
@@ -80,6 +81,7 @@ import {
 } from "./config/configValidation.js";
 import { ConfigManager } from "./config/ConfigManager.js";
 import { ClientFactory } from "./utils/ClientFactory.js";
+import type { DatabaseSelection, BucketSelection } from "./shared/selectionDialogs.js";
 
 export interface SetupOptions {
   databases?: Models.Database[];
@@ -341,6 +343,26 @@ export class UtilsController {
     return dbs.databases;
   }
 
+  async fetchAllBuckets(): Promise<{ buckets: Models.Bucket[] }> {
+    await this.init();
+    if (!this.storage) {
+      MessageFormatter.warning("Storage not initialized - buckets will be empty", { prefix: "Controller" });
+      return { buckets: [] };
+    }
+
+    try {
+      const result = await this.storage.listBuckets([
+        Query.limit(1000) // Increase limit to get all buckets
+      ]);
+
+      MessageFormatter.success(`Found ${result.buckets.length} buckets`, { prefix: "Controller" });
+      return result;
+    } catch (error: any) {
+      MessageFormatter.error(`Failed to fetch buckets: ${error.message || error}`, error instanceof Error ? error : undefined, { prefix: "Controller" });
+      return { buckets: [] };
+    }
+  }
+
   async wipeOtherDatabases(databasesToKeep: Models.Database[]) {
     await this.init();
     if (!this.database) {
@@ -636,7 +658,9 @@ export class UtilsController {
 
   async synchronizeConfigurations(
     databases?: Models.Database[],
-    config?: AppwriteConfig
+    config?: AppwriteConfig,
+    databaseSelections?: DatabaseSelection[],
+    bucketSelections?: BucketSelection[]
   ) {
     await this.init();
     if (!this.storage) {
@@ -652,21 +676,109 @@ export class UtilsController {
       MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
       return;
     }
+
+    // If selections are provided, filter the databases accordingly
+    let filteredDatabases = databases;
+    if (databaseSelections && databaseSelections.length > 0) {
+      // Convert selections to Models.Database format
+      filteredDatabases = [];
+      const allDatabases = databases ? databases : await fetchAllDatabases(this.database!);
+
+      for (const selection of databaseSelections) {
+        const database = allDatabases.find(db => db.$id === selection.databaseId);
+        if (database) {
+          filteredDatabases.push(database);
+        } else {
+          MessageFormatter.warning(`Database with ID ${selection.databaseId} not found`, { prefix: "Controller" });
+        }
+      }
+
+      MessageFormatter.info(`Syncing ${filteredDatabases.length} selected databases out of ${allDatabases.length} available`, { prefix: "Controller" });
+    }
+
     const appwriteToX = new AppwriteToX(
       configToUse,
       this.appwriteFolderPath,
       this.storage
     );
-    await appwriteToX.toSchemas(databases);
-    
+    await appwriteToX.toSchemas(filteredDatabases);
+
     // Update the controller's config with the synchronized collections
     this.config = appwriteToX.updatedConfig;
-    
+
     // Write the updated config back to disk
     const generator = new SchemaGenerator(this.config, this.appwriteFolderPath);
     const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
     const isYamlProject = !!yamlConfigPath;
     await generator.updateConfig(this.config, isYamlProject);
+
+    // Regenerate JSON schemas to reflect any table terminology fixes
+    try {
+      MessageFormatter.progress("Regenerating JSON schemas...", { prefix: "Sync" });
+      await createImportSchemas(this.appwriteFolderPath);
+      MessageFormatter.success("JSON schemas regenerated successfully", { prefix: "Sync" });
+    } catch (error) {
+      // Log error but don't fail the sync process
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      MessageFormatter.warning(
+        `Failed to regenerate JSON schemas, but sync completed: ${errorMessage}`,
+        { prefix: "Sync" }
+      );
+      logger.warn("Schema regeneration failed during sync:", error);
+    }
+  }
+
+  async selectiveSync(
+    databaseSelections: DatabaseSelection[],
+    bucketSelections: BucketSelection[]
+  ): Promise<void> {
+    await this.init();
+    if (!this.database) {
+      MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+      return;
+    }
+
+    MessageFormatter.progress("Starting selective sync...", { prefix: "Controller" });
+
+    // Convert database selections to Models.Database format
+    const selectedDatabases: Models.Database[] = [];
+
+    for (const dbSelection of databaseSelections) {
+      // Get the full database object from the controller
+      const databases = await fetchAllDatabases(this.database);
+      const database = databases.find(db => db.$id === dbSelection.databaseId);
+
+      if (database) {
+        selectedDatabases.push(database);
+        MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+
+        // Log selected tables for this database
+        if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+          MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+        }
+      } else {
+        MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+      }
+    }
+
+    if (selectedDatabases.length === 0) {
+      MessageFormatter.warning("No valid databases selected for sync", { prefix: "Controller" });
+      return;
+    }
+
+    // Log bucket selections if provided
+    if (bucketSelections && bucketSelections.length > 0) {
+      MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+      for (const bucketSelection of bucketSelections) {
+        const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+        MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+      }
+    }
+
+    // Perform selective sync using the enhanced synchronizeConfigurations method
+    await this.synchronizeConfigurations(selectedDatabases, this.config, databaseSelections, bucketSelections);
+
+    MessageFormatter.success("Selective sync completed successfully!", { prefix: "Controller" });
   }
 
   async syncDb(