appwrite-utils-cli 1.7.8 → 1.8.1

package/dist/utils/configDiscovery.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs";
-import {} from "appwrite-utils";
+import { CollectionCreateSchema } from "appwrite-utils";
 import { register } from "tsx/esm/api";
 import { pathToFileURL } from "node:url";
 import yaml from "js-yaml";
@@ -185,7 +185,7 @@ export const loadYamlCollection = (filePath) => {
         const yamlData = yaml.load(fileContent);
         const parsedCollection = YamlCollectionSchema.parse(yamlData);
         // Convert YAML collection to CollectionCreate format
-        const collection = {
+        const collectionInput = {
             name: parsedCollection.name,
             $id: parsedCollection.id || parsedCollection.name.toLowerCase().replace(/\s+/g, '_'),
             documentSecurity: parsedCollection.documentSecurity,
@@ -210,7 +210,7 @@ export const loadYamlCollection = (filePath) => {
                 twoWayKey: attr.twoWayKey,
                 onDelete: attr.onDelete,
                 side: attr.side,
-                encrypted: attr.encrypt,
+                encrypt: attr.encrypt,
                 format: attr.format
             })),
             indexes: parsedCollection.indexes.map(idx => ({
@@ -221,6 +221,7 @@ export const loadYamlCollection = (filePath) => {
             })),
             importDefs: parsedCollection.importDefs && Array.isArray(parsedCollection.importDefs) && parsedCollection.importDefs.length > 0 ? parsedCollection.importDefs : []
         };
+        const collection = CollectionCreateSchema.parse(collectionInput);
         return collection;
     }
     catch (error) {

package/dist/utils/versionDetection.d.ts

@@ -46,10 +46,6 @@ export declare function isCloudAppwriteEndpoint(endpoint: string): boolean;
  * SDK feature detection as a fallback method
  * Attempts to dynamically import TablesDB to check availability
  */
-export declare function detectSdkSupport(): Promise<{
-    tablesDbAvailable: boolean;
-    legacyAvailable: boolean;
-}>;
 /**
  * Clear version detection cache (useful for testing)
  */

package/dist/utils/versionDetection.js

@@ -11,6 +11,7 @@
  */
 import { logger } from '../shared/logging.js';
 import { MessageFormatter } from '../shared/messageFormatter.js';
+import { Client, Databases, TablesDB, Query } from 'node-appwrite';
 /**
  * Detects Appwrite API version and TablesDB support
  *
@@ -43,179 +44,70 @@ export async function detectAppwriteVersion(endpoint, project, apiKey) {
             confidence: 'high'
         };
     }
-    // STEP 2: Only proceed with endpoint probe if version >= 1.8.0 or version unknown
-    // Try primary detection method: TablesDB endpoint probe
+    // STEP 2: If version is unknown, use SDK probe (no fake HTTP endpoints)
     try {
-        logger.debug('Attempting TablesDB endpoint probe', {
+        logger.debug('Attempting SDK-based TablesDB 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;
+        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;
+        try {
+            const dbList = await databases.list([Query.limit(1)]);
+            dbId = dbList?.databases?.[0]?.$id || dbList?.databases?.[0]?.id || dbList?.[0]?.$id;
         }
-    }
-    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', {
+        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 = {
+            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'
         });
-        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;
-        }
+        return result;
     }
     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', {
+        logger.warn('SDK TablesDB probe failed; defaulting conservatively', {
             endpoint: cleanEndpoint,
             error: errorMessage,
             operation: 'detectAppwriteVersion'
         });
     }
-    // Fallback to legacy mode
+    // Final fallback: default to tablesdb for modern environments when version unknown
     const fallbackResult = {
-        apiMode: 'legacy',
+        apiMode: 'tablesdb',
         detectionMethod: 'fallback',
-        confidence: 'low'
+        confidence: 'low',
+        serverVersion: serverVersion || undefined
     };
-    logger.info('Falling back to legacy mode', {
+    logger.info('Defaulting to TablesDB mode (fallback)', {
         endpoint: cleanEndpoint,
-        totalDuration: Date.now() - startTime,
         result: fallbackResult,
         operation: 'detectAppwriteVersion'
     });
     return fallbackResult;
 }
-/**
- * Test TablesDB endpoint availability - most reliable detection method
- */
-async function probeTablesDbEndpoint(endpoint, project, apiKey) {
-    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',
-            detectionMethod: 'endpoint_probe',
-            confidence: 'high'
-        };
-        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() {
-    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
  */
@@ -320,31 +212,7 @@ export function isCloudAppwriteEndpoint(endpoint) {
  * SDK feature detection as a fallback method
  * Attempts to dynamically import TablesDB to check availability
  */
-export async function detectSdkSupport() {
-    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/dist/utils/yamlConverter.js

@@ -1,6 +1,86 @@
 import yaml from "js-yaml";
-// Threshold for treating min/max values as undefined (1 trillion)
-const MIN_MAX_THRESHOLD = 1_000_000_000_000;
+import { Decimal } from "decimal.js";
+// 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) => {
+    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) => {
+    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 };
+};
 /**
  * Converts a Collection object to YAML format with proper schema reference
  * Supports both collection and table terminology based on configuration
@@ -51,20 +131,13 @@ export function collectionToYaml(collection, config = {
             }
             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;

package/dist/utils/yamlLoader.d.ts

@@ -1,5 +1,5 @@
 import { type YamlCollectionData, type YamlTerminologyConfig } from "./yamlConverter.js";
-import type { CollectionCreate } from "appwrite-utils";
+import { type CollectionCreate } from "appwrite-utils";
 /**
  * Enhanced YAML loader with dual terminology support
  */

package/dist/utils/yamlLoader.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import { logger } from "../shared/logging.js";
 import { normalizeYamlData, usesTableTerminology, convertTerminology } from "./yamlConverter.js";
+import { CollectionCreateSchema, } from "appwrite-utils";
 /**
  * Enhanced YAML loader with dual terminology support
  */
@@ -99,7 +100,7 @@ export class YamlLoader {
     yamlToCollectionCreate(yamlData) {
         // Always normalize to ensure consistent attribute terminology
         const normalized = normalizeYamlData(yamlData);
-        return {
+        const collectionInput = {
             name: normalized.name,
             $id: normalized.id || normalized.name.toLowerCase().replace(/\s+/g, '_'),
             enabled: normalized.enabled !== false,
@@ -123,7 +124,9 @@ export class YamlLoader {
                 twoWay: attr.twoWay,
                 twoWayKey: attr.twoWayKey,
                 onDelete: attr.onDelete,
-                side: attr.side
+                side: attr.side,
+                encrypt: attr.encrypt,
+                format: attr.format
             })) || [],
             indexes: normalized.indexes?.map(idx => ({
                 key: idx.key,
@@ -133,6 +136,7 @@ export class YamlLoader {
             })) || [],
             importDefs: normalized.importDefs || []
         };
+        return CollectionCreateSchema.parse(collectionInput);
     }
     /**
      * Saves YAML data with specified terminology

package/dist/utilsController.d.ts

@@ -83,7 +83,8 @@ export declare class UtilsController {
     generateSchemas(): Promise<void>;
     importData(options?: SetupOptions): Promise<void>;
     synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig, databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
-    selectiveSync(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
+    selectivePull(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
+    selectivePush(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
     syncDb(databases?: Models.Database[], collections?: Models.Collection[]): Promise<void>;
     getAppwriteFolderPath(): string | undefined;
     transferData(options: TransferOptions): Promise<void>;