appwrite-utils-cli 1.7.9 → 1.8.2

package/src/utils/yamlConverter.ts

@@ -1,8 +1,95 @@
 import yaml from "js-yaml";
 import type { Collection, CollectionCreate } from "appwrite-utils";
+import { Decimal } from "decimal.js";
 
-// Threshold for treating min/max values as undefined (1 trillion)
-const MIN_MAX_THRESHOLD = 1_000_000_000_000;
+// Extreme values that Appwrite may return, which should be treated as undefined
+const EXTREME_MIN_INTEGER = -9223372036854776000;
+const EXTREME_MAX_INTEGER = 9223372036854776000;
+const EXTREME_MIN_FLOAT = -1.7976931348623157e+308;
+const EXTREME_MAX_FLOAT = 1.7976931348623157e+308;
+
+/**
+ * Type guard to check if an attribute has min/max properties
+ */
+const hasMinMaxProperties = (yamlAttr: any): boolean => {
+  return yamlAttr.type === 'integer' || yamlAttr.type === 'double' || yamlAttr.type === 'float';
+};
+
+/**
+ * Normalizes min/max values for integer and float attributes using Decimal.js for precision
+ * Validates that min < max and handles extreme database values
+ */
+const normalizeMinMaxValues = (yamlAttr: any): { min?: number; max?: number } => {
+  if (!hasMinMaxProperties(yamlAttr)) {
+    return {};
+  }
+
+  const { type, min, max, key } = yamlAttr;
+  let normalizedMin = min;
+  let normalizedMax = max;
+
+  // Handle min value - only filter out extreme database values
+  if (normalizedMin !== undefined && normalizedMin !== null) {
+    const minValue = Number(normalizedMin);
+    const originalMin = normalizedMin;
+
+    // Check if it's an extreme database value (but don't filter out large numbers)
+    if (type === 'integer') {
+      if (minValue === EXTREME_MIN_INTEGER) {
+        console.debug(`Min value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+        normalizedMin = undefined;
+      }
+    } else { // float/double
+      if (minValue === EXTREME_MIN_FLOAT) {
+        console.debug(`Min value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+        normalizedMin = undefined;
+      }
+    }
+  }
+
+  // Handle max value - only filter out extreme database values
+  if (normalizedMax !== undefined && normalizedMax !== null) {
+    const maxValue = Number(normalizedMax);
+    const originalMax = normalizedMax;
+
+    // Check if it's an extreme database value (but don't filter out large numbers)
+    if (type === 'integer') {
+      if (maxValue === EXTREME_MAX_INTEGER) {
+        console.debug(`Max value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+        normalizedMax = undefined;
+      }
+    } else { // float/double
+      if (maxValue === EXTREME_MAX_FLOAT) {
+        console.debug(`Max value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+        normalizedMax = undefined;
+      }
+    }
+  }
+
+  // Validate that min < max using Decimal.js for safe comparison
+  if (normalizedMin !== undefined && normalizedMax !== undefined &&
+      normalizedMin !== null && normalizedMax !== null) {
+    try {
+      const minDecimal = new Decimal(normalizedMin.toString());
+      const maxDecimal = new Decimal(normalizedMax.toString());
+
+      if (minDecimal.greaterThanOrEqualTo(maxDecimal)) {
+        // Swap values to ensure min < max (graceful handling)
+        console.warn(`Swapping min/max values for attribute '${yamlAttr.key}' to fix validation: min (${normalizedMin}) must be less than max (${normalizedMax})`);
+        const temp = normalizedMin;
+        normalizedMin = normalizedMax;
+        normalizedMax = temp;
+      }
+    } catch (error) {
+      console.error(`Error comparing min/max values for attribute '${yamlAttr.key}':`, error);
+      // If Decimal comparison fails, set both to undefined to avoid API errors
+      normalizedMin = undefined;
+      normalizedMax = undefined;
+    }
+  }
+
+  return { min: normalizedMin, max: normalizedMax };
+};
 
 export interface YamlCollectionData {
   name: string;
@@ -125,21 +212,11 @@ export function collectionToYaml(
 
       if ('xdefault' in attr && attr.xdefault !== undefined) yamlAttr.default = attr.xdefault;
 
-      // Normalize min/max values - filter out extreme database values
-      if ('min' in attr && attr.min !== undefined) {
-        const minValue = Number(attr.min);
-        // Only include min if it's within reasonable range (< 1 trillion)
-        if (Math.abs(minValue) < MIN_MAX_THRESHOLD) {
-          yamlAttr.min = attr.min;
-        }
-      }
-
-      if ('max' in attr && attr.max !== undefined) {
-        const maxValue = Number(attr.max);
-        // Only include max if it's within reasonable range (< 1 trillion)
-        if (Math.abs(maxValue) < MIN_MAX_THRESHOLD) {
-          yamlAttr.max = attr.max;
-        }
+      // Normalize min/max values using Decimal.js precision
+      if ('min' in attr || 'max' in attr) {
+        const { min, max } = normalizeMinMaxValues(attr);
+        if (min !== undefined) yamlAttr.min = min;
+        if (max !== undefined) yamlAttr.max = max;
       }
       if ('elements' in attr && attr.elements !== undefined) yamlAttr.elements = attr.elements;
       if ('relatedCollection' in attr && attr.relatedCollection !== undefined) yamlAttr.relatedCollection = attr.relatedCollection;

package/src/utils/yamlLoader.ts

@@ -9,7 +9,10 @@ import {
   type YamlCollectionData,
   type YamlTerminologyConfig
 } from "./yamlConverter.js";
-import type { CollectionCreate } from "appwrite-utils";
+import {
+  CollectionCreateSchema,
+  type CollectionCreate,
+} from "appwrite-utils";
 
 /**
  * Enhanced YAML loader with dual terminology support
@@ -149,7 +152,7 @@ export class YamlLoader {
     // Always normalize to ensure consistent attribute terminology
     const normalized = normalizeYamlData(yamlData);
 
-    return {
+    const collectionInput: CollectionCreate = {
       name: normalized.name,
       $id: normalized.id || normalized.name.toLowerCase().replace(/\s+/g, '_'),
       enabled: normalized.enabled !== false,
@@ -173,7 +176,9 @@ export class YamlLoader {
         twoWay: attr.twoWay,
         twoWayKey: attr.twoWayKey,
         onDelete: attr.onDelete as any,
-        side: attr.side as any
+        side: attr.side as any,
+        encrypt: (attr as any).encrypt,
+        format: (attr as any).format
       })) || [],
       indexes: normalized.indexes?.map(idx => ({
         key: idx.key,
@@ -183,6 +188,8 @@ export class YamlLoader {
       })) || [],
       importDefs: normalized.importDefs || []
     };
+
+    return CollectionCreateSchema.parse(collectionInput);
   }
 
   /**
@@ -361,4 +368,4 @@ export class YamlLoader {
  */
 export function createYamlLoader(baseDirectory: string): YamlLoader {
   return new YamlLoader(baseDirectory);
-}
+}

package/src/utilsController.ts

@@ -27,6 +27,7 @@ import {
 } from "./databases/setup.js";
 import {
   createOrUpdateCollections,
+  createOrUpdateCollectionsViaAdapter,
   wipeDatabase,
   generateSchemas,
   fetchAllCollections,
@@ -273,6 +274,13 @@ export class UtilsController {
     this.appwriteServer = client;
     this.adapter = adapter;
     this.config = config;
+
+    // Update config.apiMode from adapter if it's auto or not set
+    if (adapter && (!config.apiMode || config.apiMode === 'auto')) {
+      this.config.apiMode = adapter.getApiMode();
+      logger.debug(`Updated config.apiMode from adapter during init: ${this.config.apiMode}`, { prefix: "UtilsController" });
+    }
+
     this.database = new Databases(this.appwriteServer);
     this.storage = new Storage(this.appwriteServer);
     this.config.appwriteClient = this.appwriteServer;
@@ -280,7 +288,8 @@ export class UtilsController {
     // Log only on FIRST initialization to avoid spam
     if (!this.isInitialized) {
       const apiMode = adapter.getApiMode();
-      MessageFormatter.info(`Database adapter initialized (apiMode: ${apiMode})`, { prefix: "Adapter" });
+      const configApiMode = this.config.apiMode;
+      MessageFormatter.info(`Database adapter initialized (apiMode: ${apiMode}, config.apiMode: ${configApiMode})`, { prefix: "Adapter" });
       this.isInitialized = true;
     } else {
       logger.debug("Adapter reused from cache", { prefix: "UtilsController" });
@@ -601,22 +610,46 @@ export class UtilsController {
     }
   }
 
-  async createOrUpdateCollections(
-    database: Models.Database,
-    deletedCollections?: { collectionId: string; collectionName: string }[],
-    collections: Models.Collection[] = []
-  ) {
+  async createOrUpdateCollections(
+    database: Models.Database,
+    deletedCollections?: { collectionId: string; collectionName: string }[],
+    collections: Models.Collection[] = []
+  ) {
     await this.init();
     if (!this.database || !this.config)
       throw new Error("Database or config not initialized");
-    await createOrUpdateCollections(
-      this.database,
-      database.$id,
-      this.config,
-      deletedCollections,
-      collections
-    );
-  }
+
+    // Ensure apiMode is properly set from adapter
+    if (this.adapter && (!this.config.apiMode || this.config.apiMode === 'auto')) {
+      this.config.apiMode = this.adapter.getApiMode();
+      logger.debug(`Updated config.apiMode from adapter: ${this.config.apiMode}`, { prefix: "UtilsController" });
+    }
+
+    // Always prefer adapter path for unified behavior. LegacyAdapter internally translates when needed.
+    if (this.adapter) {
+      logger.debug("Using adapter for createOrUpdateCollections (unified path)", {
+        prefix: "UtilsController",
+        apiMode: this.adapter.getApiMode()
+      });
+      await createOrUpdateCollectionsViaAdapter(
+        this.adapter,
+        database.$id,
+        this.config,
+        deletedCollections,
+        collections
+      );
+    } else {
+      // Fallback if adapter is unavailable for some reason
+      logger.debug("Adapter unavailable, falling back to legacy Databases path", { prefix: "UtilsController" });
+      await createOrUpdateCollections(
+        this.database,
+        database.$id,
+        this.config,
+        deletedCollections,
+        collections
+      );
+    }
+  }
 
   async generateSchemas() {
     // Schema generation doesn't need Appwrite connection, just config
@@ -863,36 +896,53 @@ export class UtilsController {
     }
 
     // PUSH OPERATION: Push local configuration to Appwrite
-    // Build selected collections/tables from databaseSelections
-    const selectedCollections: any[] = [];
+    // Build database-specific collection mappings from databaseSelections
+    const databaseCollectionsMap = new Map<string, any[]>();
 
     // Get all collections/tables from config (they're at the root level, not nested in databases)
     const allCollections = this.config?.collections || this.config?.tables || [];
 
-    // Collect all selected table IDs from all database selections
-    const selectedTableIds = new Set<string>();
+    // Create database-specific collection mapping to preserve relationships
     for (const dbSelection of databaseSelections) {
-      for (const tableId of dbSelection.tableIds) {
-        selectedTableIds.add(tableId);
-      }
-    }
+      const collectionsForDatabase: any[] = [];
 
-    // Filter to only the selected table IDs
-    for (const collection of allCollections) {
-      const collectionId = collection.$id || (collection as any).id;
-      if (selectedTableIds.has(collectionId)) {
-        selectedCollections.push(collection);
+      MessageFormatter.info(`Processing collections for database: ${dbSelection.databaseId}`, { prefix: "Controller" });
+
+      // Filter collections that were selected for THIS specific database
+      for (const collection of allCollections) {
+        const collectionId = collection.$id || (collection as any).id;
+
+        // Check if this collection was selected for THIS database
+        if (dbSelection.tableIds.includes(collectionId)) {
+          collectionsForDatabase.push(collection);
+          MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId}`, { prefix: "Controller" });
+        }
       }
+
+      databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);
+      MessageFormatter.info(`Database ${dbSelection.databaseId}: ${collectionsForDatabase.length} collections selected`, { prefix: "Controller" });
     }
 
-    MessageFormatter.info(`Pushing ${selectedCollections.length} selected tables/collections to Appwrite`, { prefix: "Controller" });
+    // Calculate total collections for logging
+    const totalSelectedCollections = Array.from(databaseCollectionsMap.values())
+      .reduce((total, collections) => total + collections.length, 0);
+
+    MessageFormatter.info(`Pushing ${totalSelectedCollections} selected tables/collections to ${databaseCollectionsMap.size} databases`, { prefix: "Controller" });
 
     // Ensure databases exist
     await this.ensureDatabasesExist(selectedDatabases);
     await this.ensureDatabaseConfigBucketsExist(selectedDatabases);
 
-    // Create/update ONLY the selected collections/tables
-    await this.createOrUpdateCollectionsForDatabases(selectedDatabases, selectedCollections);
+    // Create/update collections with database-specific context
+    for (const database of selectedDatabases) {
+      const collectionsForThisDatabase = databaseCollectionsMap.get(database.$id) || [];
+      if (collectionsForThisDatabase.length > 0) {
+        MessageFormatter.info(`Pushing ${collectionsForThisDatabase.length} collections to database ${database.$id} (${database.name})`, { prefix: "Controller" });
+        await this.createOrUpdateCollections(database, undefined, collectionsForThisDatabase);
+      } else {
+        MessageFormatter.info(`No collections selected for database ${database.$id} (${database.name})`, { prefix: "Controller" });
+      }
+    }
 
     MessageFormatter.success("Selective push completed successfully! Local config pushed to Appwrite.", { prefix: "Controller" });
   }