appwrite-utils-cli 1.7.8 → 1.8.1

package/src/utils/versionDetection.ts

@@ -10,8 +10,9 @@
  * 3. Fallback: Default to legacy mode for safety
  */
 
-import { logger } from '../shared/logging.js';
-import { MessageFormatter } from '../shared/messageFormatter.js';
+import { logger } from '../shared/logging.js';
+import { MessageFormatter } from '../shared/messageFormatter.js';
+import { Client, Databases, TablesDB, Query } from 'node-appwrite';
 
 export type ApiMode = 'legacy' | 'tablesdb';
 
@@ -30,11 +31,11 @@ export interface VersionDetectionResult {
  * @param apiKey - API key for authentication
  * @returns Promise resolving to version detection result
  */
-export async function detectAppwriteVersion(
-  endpoint: string,
-  project: string,
-  apiKey: string
-): Promise<VersionDetectionResult> {
+export async function detectAppwriteVersion(
+  endpoint: string,
+  project: string,
+  apiKey: string
+): Promise<VersionDetectionResult> {
   const startTime = Date.now();
   // Clean endpoint URL
   const cleanEndpoint = endpoint.replace(/\/$/, '');
@@ -62,199 +63,72 @@ export async function detectAppwriteVersion(
     };
   }
 
-  // STEP 2: Only proceed with endpoint probe if version >= 1.8.0 or version unknown
-  // Try primary detection method: TablesDB endpoint probe
-  try {
-    logger.debug('Attempting TablesDB endpoint probe', {
-      endpoint: cleanEndpoint,
-      serverVersion: serverVersion || 'unknown',
-      operation: 'detectAppwriteVersion'
-    });
-
-    const probeStartTime = Date.now();
-    const tablesDbResult = await probeTablesDbEndpoint(cleanEndpoint, project, apiKey);
-    const probeDuration = Date.now() - probeStartTime;
-
-    if (tablesDbResult.apiMode === 'tablesdb') {
-      logger.info('TablesDB detected via endpoint probe', {
-        endpoint: cleanEndpoint,
-        detectionMethod: tablesDbResult.detectionMethod,
-        confidence: tablesDbResult.confidence,
-        probeDuration,
-        totalDuration: Date.now() - startTime,
-        operation: 'detectAppwriteVersion'
-      });
-      return tablesDbResult;
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-    MessageFormatter.warning(`TablesDB endpoint probe failed: ${errorMessage}`, { prefix: "Version Detection" });
-    logger.warn('TablesDB endpoint probe failed', {
-      endpoint: cleanEndpoint,
-      error: errorMessage,
-      operation: 'detectAppwriteVersion'
-    });
-  }
-  
-  // Try secondary detection method: SDK feature detection
-  try {
-    logger.debug('Attempting SDK capability probe', {
-      endpoint: cleanEndpoint,
-      operation: 'detectAppwriteVersion'
-    });
-
-    const sdkProbeStartTime = Date.now();
-    const sdkResult = await probeSdkCapabilities();
-    const sdkProbeDuration = Date.now() - sdkProbeStartTime;
-
-    if (sdkResult.apiMode === 'tablesdb') {
-      logger.info('TablesDB detected via SDK capability probe', {
-        endpoint: cleanEndpoint,
-        detectionMethod: sdkResult.detectionMethod,
-        confidence: sdkResult.confidence,
-        sdkProbeDuration,
-        totalDuration: Date.now() - startTime,
-        operation: 'detectAppwriteVersion'
-      });
-      return sdkResult;
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-    MessageFormatter.warning(`SDK capability probe failed: ${errorMessage}`, { prefix: "Version Detection" });
-    logger.warn('SDK capability probe failed', {
-      endpoint: cleanEndpoint,
-      error: errorMessage,
-      operation: 'detectAppwriteVersion'
-    });
-  }
-
-  // Fallback to legacy mode
-  const fallbackResult = {
-    apiMode: 'legacy' as ApiMode,
-    detectionMethod: 'fallback' as const,
-    confidence: 'low' as const
-  };
+  // STEP 2: If version is unknown, use SDK probe (no fake HTTP endpoints)
+  try {
+    logger.debug('Attempting SDK-based TablesDB probe', {
+      endpoint: cleanEndpoint,
+      operation: 'detectAppwriteVersion'
+    });
+
+    const client = new Client().setEndpoint(cleanEndpoint).setProject(project);
+    if (apiKey && apiKey.trim().length > 0) client.setKey(apiKey);
+
+    const databases = new Databases(client);
+    // Try to get a database id to probe tables listing
+    let dbId: string | undefined;
+    try {
+      const dbList: any = await databases.list([Query.limit(1)]);
+      dbId = dbList?.databases?.[0]?.$id || dbList?.databases?.[0]?.id || dbList?.[0]?.$id;
+    } catch (e) {
+      // Ignore, we'll still attempt a conservative probe
+      logger.debug('Databases.list probe failed or returned no items', { operation: 'detectAppwriteVersion' });
+    }
+
+    const tables = new TablesDB(client);
+    if (dbId) {
+      // Probe listTables for the first database (limit 1)
+      await tables.listTables({ databaseId: dbId, queries: [Query.limit(1)] });
+    } else {
+      // No databases to probe; assume TablesDB available (cannot falsify-positively without a db)
+      logger.debug('No databases found to probe tables; assuming TablesDB if SDK available', { operation: 'detectAppwriteVersion' });
+    }
+
+    const result: VersionDetectionResult = {
+      apiMode: 'tablesdb',
+      detectionMethod: 'endpoint_probe', // repurpose label for SDK probe
+      confidence: 'medium',
+      serverVersion: serverVersion || undefined
+    };
+    logger.info('TablesDB detected via SDK probe', {
+      endpoint: cleanEndpoint,
+      result,
+      operation: 'detectAppwriteVersion'
+    });
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    logger.warn('SDK TablesDB probe failed; defaulting conservatively', {
+      endpoint: cleanEndpoint,
+      error: errorMessage,
+      operation: 'detectAppwriteVersion'
+    });
+  }
+
+  // Final fallback: default to tablesdb for modern environments when version unknown
+  const fallbackResult: VersionDetectionResult = {
+    apiMode: 'tablesdb',
+    detectionMethod: 'fallback',
+    confidence: 'low',
+    serverVersion: serverVersion || undefined
+  };
+  logger.info('Defaulting to TablesDB mode (fallback)', {
+    endpoint: cleanEndpoint,
+    result: fallbackResult,
+    operation: 'detectAppwriteVersion'
+  });
+  return fallbackResult;
+}
 
-  logger.info('Falling back to legacy mode', {
-    endpoint: cleanEndpoint,
-    totalDuration: Date.now() - startTime,
-    result: fallbackResult,
-    operation: 'detectAppwriteVersion'
-  });
-
-  return fallbackResult;
-}
-
-/**
- * Test TablesDB endpoint availability - most reliable detection method
- */
-async function probeTablesDbEndpoint(
-  endpoint: string,
-  project: string,
-  apiKey: string
-): Promise<VersionDetectionResult> {
-  const startTime = Date.now();
-  const url = `${endpoint}/tablesdb/`;
-
-  logger.debug('Probing TablesDB endpoint', {
-    url,
-    project,
-    operation: 'probeTablesDbEndpoint'
-  });
-
-  const response = await fetch(url, {
-    method: 'GET',
-    headers: {
-      'Content-Type': 'application/json',
-      'X-Appwrite-Project': project,
-      'X-Appwrite-Key': apiKey
-    },
-    // Short timeout for faster detection
-    signal: AbortSignal.timeout(5000)
-  });
-
-  const duration = Date.now() - startTime;
-
-  logger.debug('TablesDB endpoint response received', {
-    url,
-    status: response.status,
-    statusText: response.statusText,
-    duration,
-    operation: 'probeTablesDbEndpoint'
-  });
-
-  if (response.ok) {
-    // ONLY 200 OK means TablesDB available
-    // 404 means endpoint doesn't exist (server < 1.8.0)
-    const result = {
-      apiMode: 'tablesdb' as ApiMode,
-      detectionMethod: 'endpoint_probe' as const,
-      confidence: 'high' as const
-    };
-
-    logger.info('TablesDB endpoint probe successful', {
-      url,
-      status: response.status,
-      result,
-      duration,
-      operation: 'probeTablesDbEndpoint'
-    });
-
-    return result;
-  }
-
-  // 501 Not Implemented or other errors = no TablesDB support
-  const error = new Error(`TablesDB endpoint returned ${response.status}: ${response.statusText}`);
-  logger.debug('TablesDB endpoint probe failed', {
-    url,
-    status: response.status,
-    statusText: response.statusText,
-    duration,
-    operation: 'probeTablesDbEndpoint'
-  });
-  throw error;
-}
-
-/**
- * SDK capability detection as secondary method
- */
-async function probeSdkCapabilities(): Promise<VersionDetectionResult> {
-  try {
-    // Try to import TablesDB SDK
-    let TablesDBModule;
-    try {
-      TablesDBModule = await import('node-appwrite-tablesdb');
-    } catch (importError) {
-      // TablesDB SDK not available, will fall back to legacy
-    }
-    
-    if (TablesDBModule?.TablesDB) {
-      return {
-        apiMode: 'tablesdb',
-        detectionMethod: 'endpoint_probe',
-        confidence: 'medium'
-      };
-    }
-  } catch (error) {
-    // TablesDB SDK not available, assume legacy
-  }
-  
-  // Check for legacy SDK availability
-  try {
-    const { Databases } = await import('node-appwrite');
-    if (Databases) {
-      return {
-        apiMode: 'legacy',
-        detectionMethod: 'endpoint_probe',
-        confidence: 'medium'
-      };
-    }
-  } catch (error) {
-    throw new Error('No Appwrite SDK available');
-  }
-  
-  throw new Error('Unable to determine SDK capabilities');
-}
 
 /**
  * Cached version detection to avoid repeated API calls
@@ -381,35 +255,7 @@ export function isCloudAppwriteEndpoint(endpoint: string): boolean {
  * SDK feature detection as a fallback method
  * Attempts to dynamically import TablesDB to check availability
  */
-export async function detectSdkSupport(): Promise<{
-  tablesDbAvailable: boolean;
-  legacyAvailable: boolean;
-}> {
-  const result = {
-    tablesDbAvailable: false,
-    legacyAvailable: false
-  };
-  
-  // Test TablesDB SDK availability
-  try {
-    const tablesModule = await import('node-appwrite-tablesdb');
-    if (tablesModule) {
-      result.tablesDbAvailable = true;
-    }
-  } catch (error) {
-    // TablesDB SDK not available
-  }
-  
-  // Test legacy SDK availability  
-  try {
-    await import('node-appwrite');
-    result.legacyAvailable = true;
-  } catch (error) {
-    // Legacy SDK not available
-  }
-  
-  return result;
-}
+// Removed dynamic SDK capability checks to avoid confusion and side effects.
 
 /**
  * Clear version detection cache (useful for testing)

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);
-}
+}