appwrite-utils-cli 1.6.6 → 1.6.8

package/dist/collections/attributes.js

@@ -607,6 +607,13 @@ const attributesSame = (databaseAttribute, configAttribute) => {
             operation: 'attributesSame'
         });
     }
+    // Log differences if comparison failed (for debugging)
+    if (!result && differences.length > 0) {
+        MessageFormatter.debug(`Attribute '${configAttribute.key}' differences detected:`, { prefix: "Attributes" });
+        differences.forEach(diff => {
+            MessageFormatter.debug(`  ${diff}`, { prefix: "Attributes" });
+        });
+    }
     return result;
 };
 /**

package/dist/collections/methods.js

@@ -224,9 +224,9 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         attributes);
         // Add delay after creating attributes
         await delay(250);
-        // ALWAYS use indexes from local config, NEVER from server
+        // Prefer local config indexes, but fall back to collection's own indexes if no local config exists
         const localCollectionConfig = config.collections?.find(c => c.name === collectionData.name || c.$id === collectionData.$id);
-        const indexesToUse = localCollectionConfig?.indexes || [];
+        const indexesToUse = localCollectionConfig?.indexes ?? indexes ?? [];
         MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
         await createOrUpdateIndexesWithStatusCheck(databaseId, database, collectionToUse.$id, collectionToUse, indexesToUse);
         // Delete indexes that exist on server but not in local config
@@ -428,9 +428,9 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 }
             }
         }
-        // ALWAYS use indexes from local config, NEVER from server (TablesDB path)
+        // Prefer local config indexes, but fall back to collection's own indexes if no local config exists (TablesDB path)
         const localTableConfig = config.collections?.find(c => c.name === collectionData.name || c.$id === collectionData.$id);
-        const idxs = (localTableConfig?.indexes || []);
+        const idxs = (localTableConfig?.indexes ?? indexes ?? []);
         for (const idx of idxs) {
             try {
                 await adapter.createIndex({

package/dist/config/services/ConfigLoaderService.d.ts

@@ -90,6 +90,23 @@ export declare class ConfigLoaderService {
             source2: string;
         }>;
     }>;
+    /**
+     * Loads tables first (higher priority), then collections (backward compatibility)
+     * Used for TablesDB projects (>= 1.8.0)
+     * @param tablesDir Path to the tables directory
+     * @param collectionsDir Path to the collections directory
+     * @returns Loading result with items, counts, and conflicts
+     */
+    loadTablesFirst(tablesDir: string, collectionsDir: string): Promise<{
+        items: Collection[];
+        fromCollections: number;
+        fromTables: number;
+        conflicts: Array<{
+            name: string;
+            source1: string;
+            source2: string;
+        }>;
+    }>;
     /**
      * Validates that a configuration file can be loaded
      * @param configPath Path to the configuration file

package/dist/config/services/ConfigLoaderService.js

@@ -112,6 +112,42 @@ export class ConfigLoaderService {
                     };
                 }
             }
+            // Load collections and tables from their respective directories
+            const configDir = path.dirname(yamlPath);
+            const collectionsDir = path.join(configDir, config.schemaConfig?.collectionsDirectory || "collections");
+            const tablesDir = path.join(configDir, config.schemaConfig?.tablesDirectory || "tables");
+            // Detect API mode to determine priority order
+            let apiMode = 'legacy';
+            try {
+                const { detectAppwriteVersionCached } = await import('../../utils/versionDetection.js');
+                const detection = await detectAppwriteVersionCached(config.appwriteEndpoint, config.appwriteProject, config.appwriteKey);
+                apiMode = detection.apiMode;
+            }
+            catch {
+                // Fallback to legacy if detection fails
+            }
+            // Load with correct priority based on API mode
+            const { items, conflicts, fromCollections, fromTables } = apiMode === 'tablesdb'
+                ? await this.loadTablesFirst(tablesDir, collectionsDir)
+                : await this.loadCollectionsAndTables(collectionsDir, tablesDir);
+            config.collections = items;
+            // Report what was loaded
+            if (fromTables > 0 && fromCollections > 0) {
+                MessageFormatter.success(`Loaded ${items.length} total items: ${fromCollections} from collections/, ${fromTables} from tables/`, { prefix: "Config" });
+            }
+            else if (fromCollections > 0) {
+                MessageFormatter.success(`Loaded ${fromCollections} collections from collections/`, { prefix: "Config" });
+            }
+            else if (fromTables > 0) {
+                MessageFormatter.success(`Loaded ${fromTables} tables from tables/`, { prefix: "Config" });
+            }
+            // Report conflicts
+            if (conflicts.length > 0) {
+                MessageFormatter.warning(`Found ${conflicts.length} naming conflicts`, { prefix: "Config" });
+                conflicts.forEach(conflict => {
+                    MessageFormatter.info(`  - '${conflict.name}': ${conflict.source1} (used) vs ${conflict.source2} (skipped)`, { prefix: "Config" });
+                });
+            }
             MessageFormatter.success(`Loaded YAML config from: ${yamlPath}`, {
                 prefix: "Config",
             });
@@ -377,6 +413,54 @@ export class ConfigLoaderService {
             conflicts,
         };
     }
+    /**
+     * Loads tables first (higher priority), then collections (backward compatibility)
+     * Used for TablesDB projects (>= 1.8.0)
+     * @param tablesDir Path to the tables directory
+     * @param collectionsDir Path to the collections directory
+     * @returns Loading result with items, counts, and conflicts
+     */
+    async loadTablesFirst(tablesDir, collectionsDir) {
+        const items = [];
+        const loadedNames = new Set();
+        const conflicts = [];
+        // Load from tables/ directory first (HIGHER priority for TablesDB)
+        if (fs.existsSync(tablesDir)) {
+            const tables = await this.loadTables(tablesDir, { markAsTablesDir: true });
+            for (const table of tables) {
+                const name = table.name || table.tableId || table.$id || "";
+                loadedNames.add(name);
+                items.push(table);
+            }
+        }
+        // Load from collections/ directory second (LOWER priority, backward compatibility)
+        if (fs.existsSync(collectionsDir)) {
+            const collections = await this.loadCollections(collectionsDir);
+            for (const collection of collections) {
+                const name = collection.name || collection.$id || "";
+                // Check for conflicts - tables win
+                if (loadedNames.has(name)) {
+                    conflicts.push({
+                        name,
+                        source1: "tables/",
+                        source2: "collections/",
+                    });
+                }
+                else {
+                    loadedNames.add(name);
+                    items.push(collection);
+                }
+            }
+        }
+        const fromTables = items.filter((item) => item._isFromTablesDir).length;
+        const fromCollections = items.filter((item) => !item._isFromTablesDir).length;
+        return {
+            items,
+            fromCollections,
+            fromTables,
+            conflicts,
+        };
+    }
     /**
      * Validates that a configuration file can be loaded
      * @param configPath Path to the configuration file

package/dist/migrations/yaml/generateImportSchemas.js

@@ -462,6 +462,14 @@ export function generateCollectionSchema() {
                     "side": {
                         "type": "string",
                         "enum": ["parent", "child"]
+                    },
+                    "encrypt": {
+                        "type": "boolean",
+                        "description": "Whether the attribute should be encrypted"
+                    },
+                    "format": {
+                        "type": "string",
+                        "description": "Format for string attributes (e.g., email, url, ip)"
                     }
                 },
                 "required": ["key", "type"],

package/dist/utils/configDiscovery.js

@@ -123,7 +123,9 @@ const YamlCollectionSchema = z.object({
         twoWay: z.boolean().optional(),
         twoWayKey: z.string().optional(),
         onDelete: z.string().optional(),
-        side: 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(),
@@ -168,7 +170,9 @@ export const loadYamlCollection = (filePath) => {
                 twoWay: attr.twoWay,
                 twoWayKey: attr.twoWayKey,
                 onDelete: attr.onDelete,
-                side: attr.side
+                side: attr.side,
+                encrypted: attr.encrypt,
+                format: attr.format
             })),
             indexes: parsedCollection.indexes.map(idx => ({
                 key: idx.key,
@@ -221,7 +225,9 @@ export const loadYamlTable = (filePath) => {
                 twoWay: attr.twoWay,
                 twoWayKey: attr.twoWayKey,
                 onDelete: attr.onDelete,
-                side: attr.side
+                side: attr.side,
+                encrypted: attr.encrypt,
+                format: attr.format
             })),
             indexes: parsedTable.indexes.map(idx => ({
                 key: idx.key,

package/dist/utils/setupFiles.js

@@ -479,6 +479,14 @@ importDefs: []
                                 "type": "string",
                                 "description": "Column description"
                             },
+                            "encrypt": {
+                                "type": "boolean",
+                                "description": "Whether the column should be encrypted"
+                            },
+                            "format": {
+                                "type": "string",
+                                "description": "Format for string columns"
+                            },
                             "min": {
                                 "type": "number",
                                 "description": "Minimum value for numeric columns"
@@ -673,6 +681,14 @@ importDefs: []
                                 "type": "string",
                                 "description": "Attribute description"
                             },
+                            "encrypt": {
+                                "type": "boolean",
+                                "description": "Whether the attribute should be encrypted"
+                            },
+                            "format": {
+                                "type": "string",
+                                "description": "Format for string attributes"
+                            },
                             "min": {
                                 "type": "number",
                                 "description": "Minimum value for numeric attributes"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/collections/attributes.ts

@@ -935,6 +935,17 @@ const attributesSame = (
     });
   }
 
+  // Log differences if comparison failed (for debugging)
+  if (!result && differences.length > 0) {
+    MessageFormatter.debug(
+      `Attribute '${configAttribute.key}' differences detected:`,
+      { prefix: "Attributes" }
+    );
+    differences.forEach(diff => {
+      MessageFormatter.debug(`  ${diff}`, { prefix: "Attributes" });
+    });
+  }
+
   return result;
 };
 

package/src/collections/methods.ts

@@ -339,11 +339,11 @@ export const createOrUpdateCollections = async (
     // Add delay after creating attributes
     await delay(250);
 
-    // ALWAYS use indexes from local config, NEVER from server
+    // Prefer local config indexes, but fall back to collection's own indexes if no local config exists
     const localCollectionConfig = config.collections?.find(
       c => c.name === collectionData.name || c.$id === collectionData.$id
     );
-    const indexesToUse = localCollectionConfig?.indexes || [];
+    const indexesToUse = localCollectionConfig?.indexes ?? indexes ?? [];
 
     MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
     await createOrUpdateIndexesWithStatusCheck(
@@ -575,11 +575,11 @@ export const createOrUpdateCollectionsViaAdapter = async (
       }
     }
 
-    // ALWAYS use indexes from local config, NEVER from server (TablesDB path)
+    // Prefer local config indexes, but fall back to collection's own indexes if no local config exists (TablesDB path)
     const localTableConfig = config.collections?.find(
       c => c.name === collectionData.name || c.$id === collectionData.$id
     );
-    const idxs = (localTableConfig?.indexes || []) as any[];
+    const idxs = (localTableConfig?.indexes ?? indexes ?? []) as any[];
     for (const idx of idxs) {
       try {
         await adapter.createIndex({

package/src/config/services/ConfigLoaderService.ts

@@ -153,6 +153,64 @@ export class ConfigLoaderService {
         }
       }
 
+      // Load collections and tables from their respective directories
+      const configDir = path.dirname(yamlPath);
+      const collectionsDir = path.join(configDir, config.schemaConfig?.collectionsDirectory || "collections");
+      const tablesDir = path.join(configDir, config.schemaConfig?.tablesDirectory || "tables");
+
+      // Detect API mode to determine priority order
+      let apiMode: 'legacy' | 'tablesdb' = 'legacy';
+      try {
+        const { detectAppwriteVersionCached } = await import('../../utils/versionDetection.js');
+        const detection = await detectAppwriteVersionCached(
+          config.appwriteEndpoint,
+          config.appwriteProject,
+          config.appwriteKey
+        );
+        apiMode = detection.apiMode;
+      } catch {
+        // Fallback to legacy if detection fails
+      }
+
+      // Load with correct priority based on API mode
+      const { items, conflicts, fromCollections, fromTables } = apiMode === 'tablesdb'
+        ? await this.loadTablesFirst(tablesDir, collectionsDir)
+        : await this.loadCollectionsAndTables(collectionsDir, tablesDir);
+
+      config.collections = items;
+
+      // Report what was loaded
+      if (fromTables > 0 && fromCollections > 0) {
+        MessageFormatter.success(
+          `Loaded ${items.length} total items: ${fromCollections} from collections/, ${fromTables} from tables/`,
+          { prefix: "Config" }
+        );
+      } else if (fromCollections > 0) {
+        MessageFormatter.success(
+          `Loaded ${fromCollections} collections from collections/`,
+          { prefix: "Config" }
+        );
+      } else if (fromTables > 0) {
+        MessageFormatter.success(
+          `Loaded ${fromTables} tables from tables/`,
+          { prefix: "Config" }
+        );
+      }
+
+      // Report conflicts
+      if (conflicts.length > 0) {
+        MessageFormatter.warning(
+          `Found ${conflicts.length} naming conflicts`,
+          { prefix: "Config" }
+        );
+        conflicts.forEach(conflict => {
+          MessageFormatter.info(
+            `  - '${conflict.name}': ${conflict.source1} (used) vs ${conflict.source2} (skipped)`,
+            { prefix: "Config" }
+          );
+        });
+      }
+
       MessageFormatter.success(`Loaded YAML config from: ${yamlPath}`, {
         prefix: "Config",
       });
@@ -523,6 +581,67 @@ export class ConfigLoaderService {
     };
   }
 
+  /**
+   * Loads tables first (higher priority), then collections (backward compatibility)
+   * Used for TablesDB projects (>= 1.8.0)
+   * @param tablesDir Path to the tables directory
+   * @param collectionsDir Path to the collections directory
+   * @returns Loading result with items, counts, and conflicts
+   */
+  public async loadTablesFirst(
+    tablesDir: string,
+    collectionsDir: string
+  ): Promise<{
+    items: Collection[];
+    fromCollections: number;
+    fromTables: number;
+    conflicts: Array<{ name: string; source1: string; source2: string }>;
+  }> {
+    const items: Collection[] = [];
+    const loadedNames = new Set<string>();
+    const conflicts: Array<{ name: string; source1: string; source2: string }> = [];
+
+    // Load from tables/ directory first (HIGHER priority for TablesDB)
+    if (fs.existsSync(tablesDir)) {
+      const tables = await this.loadTables(tablesDir, { markAsTablesDir: true });
+      for (const table of tables) {
+        const name = table.name || table.tableId || table.$id || "";
+        loadedNames.add(name);
+        items.push(table);
+      }
+    }
+
+    // Load from collections/ directory second (LOWER priority, backward compatibility)
+    if (fs.existsSync(collectionsDir)) {
+      const collections = await this.loadCollections(collectionsDir);
+      for (const collection of collections) {
+        const name = collection.name || collection.$id || "";
+
+        // Check for conflicts - tables win
+        if (loadedNames.has(name)) {
+          conflicts.push({
+            name,
+            source1: "tables/",
+            source2: "collections/",
+          });
+        } else {
+          loadedNames.add(name);
+          items.push(collection);
+        }
+      }
+    }
+
+    const fromTables = items.filter((item: any) => item._isFromTablesDir).length;
+    const fromCollections = items.filter((item: any) => !item._isFromTablesDir).length;
+
+    return {
+      items,
+      fromCollections,
+      fromTables,
+      conflicts,
+    };
+  }
+
   /**
    * Validates that a configuration file can be loaded
    * @param configPath Path to the configuration file

package/src/migrations/yaml/generateImportSchemas.ts

@@ -464,6 +464,14 @@ export function generateCollectionSchema(): any {
           "side": {
             "type": "string",
             "enum": ["parent", "child"]
+          },
+          "encrypt": {
+            "type": "boolean",
+            "description": "Whether the attribute should be encrypted"
+          },
+          "format": {
+            "type": "string",
+            "description": "Format for string attributes (e.g., email, url, ip)"
           }
         },
         "required": ["key", "type"],

package/src/utils/configDiscovery.ts

@@ -139,7 +139,9 @@ const YamlCollectionSchema = z.object({
       twoWay: z.boolean().optional(),
       twoWayKey: z.string().optional(),
       onDelete: z.string().optional(),
-      side: z.string().optional()
+      side: z.string().optional(),
+      encrypt: z.boolean().optional(),
+      format: z.string().optional()
     })
   ).optional().default([]),
   indexes: z.array(
@@ -191,7 +193,9 @@ export const loadYamlCollection = (filePath: string): CollectionCreate | null =>
         twoWay: attr.twoWay,
         twoWayKey: attr.twoWayKey,
         onDelete: attr.onDelete as any,
-        side: attr.side as any
+        side: attr.side as any,
+        encrypted: (attr as any).encrypt,
+        format: (attr as any).format
       })),
       indexes: parsedCollection.indexes.map(idx => ({
         key: idx.key,
@@ -247,7 +251,9 @@ export const loadYamlTable = (filePath: string): any | null => {
         twoWay: attr.twoWay,
         twoWayKey: attr.twoWayKey,
         onDelete: attr.onDelete as any,
-        side: attr.side as any
+        side: attr.side as any,
+        encrypted: (attr as any).encrypt,
+        format: (attr as any).format
       })),
       indexes: parsedTable.indexes.map(idx => ({
         key: idx.key,

package/src/utils/setupFiles.ts

@@ -516,6 +516,14 @@ importDefs: []
                 "type": "string",
                 "description": "Column description"
               },
+              "encrypt": {
+                "type": "boolean",
+                "description": "Whether the column should be encrypted"
+              },
+              "format": {
+                "type": "string",
+                "description": "Format for string columns"
+              },
               "min": {
                 "type": "number",
                 "description": "Minimum value for numeric columns"
@@ -710,6 +718,14 @@ importDefs: []
                 "type": "string",
                 "description": "Attribute description"
               },
+              "encrypt": {
+                "type": "boolean",
+                "description": "Whether the attribute should be encrypted"
+              },
+              "format": {
+                "type": "string",
+                "description": "Format for string attributes"
+              },
               "min": {
                 "type": "number",
                 "description": "Minimum value for numeric attributes"