appwrite-utils-cli 1.6.4 → 1.6.6

package/dist/collections/indexes.js

@@ -3,6 +3,8 @@ import { Databases, IndexType, Query } from "node-appwrite";
 import { delay, tryAwaitWithRetry, calculateExponentialBackoff } from "../utils/helperFunctions.js";
 import { isLegacyDatabases } from "../utils/typeGuards.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
+// System attributes that are always available for indexing in Appwrite
+const SYSTEM_ATTRIBUTES = ['$id', '$createdAt', '$updatedAt', '$permissions'];
 /**
  * Wait for index to become available, with retry logic for stuck indexes and exponential backoff
  */
@@ -72,10 +74,12 @@ export const createOrUpdateIndexWithStatusCheck = async (dbId, db, collectionId,
         // First, validate that all required attributes exist
         const freshCollection = await db.getCollection(dbId, collectionId);
         const existingAttributeKeys = freshCollection.attributes.map((attr) => attr.key);
-        const missingAttributes = index.attributes.filter(attr => !existingAttributeKeys.includes(attr));
+        // Include system attributes that are always available
+        const allAvailableAttributes = [...existingAttributeKeys, ...SYSTEM_ATTRIBUTES];
+        const missingAttributes = index.attributes.filter(attr => !allAvailableAttributes.includes(attr));
         if (missingAttributes.length > 0) {
             MessageFormatter.error(`Index '${index.key}' cannot be created: missing attributes [${missingAttributes.join(', ')}] (type: ${index.type})`);
-            MessageFormatter.error(`Available attributes: [${existingAttributeKeys.join(', ')}]`);
+            MessageFormatter.error(`Available attributes: [${existingAttributeKeys.join(', ')}, ${SYSTEM_ATTRIBUTES.join(', ')}]`);
             return false; // Don't retry if attributes are missing
         }
         // Try to create/update the index using existing logic
@@ -169,15 +173,38 @@ export const createOrUpdateIndex = async (dbId, db, collectionId, index) => {
         // No existing index, create it
         createIndex = true;
     }
-    else if (!existingIndex.indexes.some((existingIndex) => (existingIndex.key === index.key &&
-        existingIndex.type === index.type &&
-        existingIndex.attributes === index.attributes))) {
-        // Existing index doesn't match, delete and recreate
-        await db.deleteIndex(dbId, collectionId, existingIndex.indexes[0].key);
-        createIndex = true;
+    else {
+        const existing = existingIndex.indexes[0];
+        // Check key and type
+        const keyMatches = existing.key === index.key;
+        const typeMatches = existing.type === index.type;
+        // Compare attributes as SETS (order doesn't matter, only content)
+        const existingAttrsSet = new Set(existing.attributes);
+        const newAttrsSet = new Set(index.attributes);
+        const attributesMatch = existingAttrsSet.size === newAttrsSet.size &&
+            [...existingAttrsSet].every(attr => newAttrsSet.has(attr));
+        // Compare orders as SETS if both exist (order doesn't matter)
+        let ordersMatch = true;
+        if (index.orders && existing.orders) {
+            const existingOrdersSet = new Set(existing.orders);
+            const newOrdersSet = new Set(index.orders);
+            ordersMatch =
+                existingOrdersSet.size === newOrdersSet.size &&
+                    [...existingOrdersSet].every(ord => newOrdersSet.has(ord));
+        }
+        // Only recreate if something genuinely changed
+        if (!keyMatches || !typeMatches || !attributesMatch || !ordersMatch) {
+            await db.deleteIndex(dbId, collectionId, existing.key);
+            createIndex = true;
+        }
     }
     if (createIndex) {
-        newIndex = await db.createIndex(dbId, collectionId, index.key, index.type, index.attributes, index.orders);
+        // Ensure orders array exists and matches attributes length
+        // Default to "asc" for each attribute if not specified
+        const orders = index.orders && index.orders.length === index.attributes.length
+            ? index.orders
+            : index.attributes.map(() => "asc");
+        newIndex = await db.createIndex(dbId, collectionId, index.key, index.type, index.attributes, orders);
     }
     return newIndex;
 };

package/dist/collections/methods.js

@@ -68,7 +68,8 @@ export const checkForCollection = async (db, dbId, collection) => {
         const items = isLegacyDatabases(db) ? response.collections : (response.tables || response.collections);
         if (items && items.length > 0) {
             MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
-            return { ...collection, ...items[0] };
+            // Return remote collection for update operations (don't merge local config over it)
+            return items[0];
         }
         else {
             MessageFormatter.info(`No collection found with name: ${collection.name}`, { prefix: "Collections" });
@@ -223,12 +224,14 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         attributes);
         // Add delay after creating attributes
         await delay(250);
-        const indexesToUse = indexes && indexes.length > 0
-            ? indexes
-            : config.collections?.find((c) => c.$id === collectionToUse.$id)
-                ?.indexes ?? [];
+        // ALWAYS use indexes from local config, NEVER from server
+        const localCollectionConfig = config.collections?.find(c => c.name === collectionData.name || c.$id === collectionData.$id);
+        const indexesToUse = localCollectionConfig?.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
+        const { deleteObsoleteIndexes } = await import('../shared/indexManager.js');
+        await deleteObsoleteIndexes(database, databaseId, collectionToUse, { indexes: indexesToUse }, { verbose: true });
         // Mark this collection as fully processed to prevent re-processing
         markCollectionProcessed(collectionToUse.$id, collectionData.name);
         // Add delay after creating indexes
@@ -425,8 +428,9 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 }
             }
         }
-        // Indexes
-        const idxs = (indexes || []);
+        // ALWAYS use indexes from local config, NEVER from server (TablesDB path)
+        const localTableConfig = config.collections?.find(c => c.name === collectionData.name || c.$id === collectionData.$id);
+        const idxs = (localTableConfig?.indexes || []);
         for (const idx of idxs) {
             try {
                 await adapter.createIndex({

package/dist/main.js

@@ -697,24 +697,19 @@ async function main() {
                 operationStats.wipedBuckets = wipeStats.buckets;
             }
         }
-        if (parsedArgv.push || parsedArgv.sync) {
+        if (parsedArgv.push) {
+            // PUSH: Use LOCAL config collections only (pass empty array to use config.collections)
             const databases = options.databases || (await fetchAllDatabases(controller.database));
-            let collections = [];
-            if (options.collections) {
-                for (const db of databases) {
-                    const dbCollections = await fetchAllCollections(db.$id, controller.database);
-                    collections = collections.concat(dbCollections.filter((c) => options.collections.includes(c.$id)));
-                }
-            }
-            if (parsedArgv.push) {
-                await controller.syncDb(databases, collections);
-                operationStats.pushedDatabases = databases.length;
-                operationStats.pushedCollections = collections.length;
-            }
-            else if (parsedArgv.sync) {
-                await controller.synchronizeConfigurations(databases);
-                operationStats.syncedDatabases = databases.length;
-            }
+            // Pass empty array - syncDb will use config.collections (local schema)
+            await controller.syncDb(databases, []);
+            operationStats.pushedDatabases = databases.length;
+            operationStats.pushedCollections = controller.config?.collections?.length || 0;
+        }
+        else if (parsedArgv.sync) {
+            // SYNC: Pull from remote
+            const databases = options.databases || (await fetchAllDatabases(controller.database));
+            await controller.synchronizeConfigurations(databases);
+            operationStats.syncedDatabases = databases.length;
         }
         if (options.generateSchemas) {
             await controller.generateSchemas();

package/dist/setupCommands.d.ts

@@ -1 +1,58 @@
+import { type ApiMode } from "./utils/versionDetection.js";
+/**
+ * Terminology configuration for API mode-specific naming
+ */
+interface TerminologyConfig {
+    container: "table" | "collection";
+    containerName: "Table" | "Collection";
+    fields: "columns" | "attributes";
+    fieldName: "Column" | "Attribute";
+    security: "rowSecurity" | "documentSecurity";
+    schemaRef: "table.schema.json" | "collection.schema.json";
+    items: "rows" | "documents";
+}
+/**
+ * Detection result with source information
+ */
+interface ApiModeDetectionResult {
+    apiMode: ApiMode;
+    useTables: boolean;
+    detectionSource: "appwrite.json" | "server-version" | "default";
+    serverVersion?: string;
+}
+/**
+ * Get terminology configuration based on API mode
+ */
+export declare function getTerminologyConfig(useTables: boolean): TerminologyConfig;
+/**
+ * Detect API mode using multiple detection sources
+ * Priority: appwrite.json > server version > default (collections)
+ */
+export declare function detectApiMode(basePath: string): Promise<ApiModeDetectionResult>;
+/**
+ * Create directory structure for Appwrite project
+ */
+export declare function createProjectDirectories(basePath: string, useTables: boolean): {
+    appwriteFolder: string;
+    containerFolder: string;
+    schemaFolder: string;
+    yamlSchemaFolder: string;
+    dataFolder: string;
+};
+/**
+ * Create example YAML schema file with correct terminology
+ */
+export declare function createExampleSchema(containerFolder: string, terminology: TerminologyConfig): string;
+/**
+ * Create JSON schema for YAML validation
+ */
+export declare function createYamlValidationSchema(yamlSchemaFolder: string, useTables: boolean): string;
+/**
+ * Initialize a new Appwrite project with correct directory structure and terminology
+ */
+export declare function initProject(basePath?: string, forceApiMode?: 'legacy' | 'tablesdb'): Promise<void>;
+/**
+ * Create a new collection or table schema file
+ */
+export declare function createSchema(name: string, basePath?: string, forceApiMode?: 'legacy' | 'tablesdb'): Promise<void>;
 export {};