appwrite-utils-cli 1.7.9 → 1.8.2

package/src/shared/attributeMapper.ts

@@ -0,0 +1,229 @@
+import type { CreateAttributeParams, UpdateAttributeParams } from "../adapters/DatabaseAdapter.js";
+import type { Attribute } from "appwrite-utils";
+
+function ensureNumber(n: any): number | undefined {
+  if (n === null || n === undefined) return undefined;
+  const num = Number(n);
+  return Number.isFinite(num) ? num : undefined;
+}
+
+/**
+ * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
+ * Only includes fields valid for the specific type to satisfy TS unions.
+ * Also normalizes min/max ordering for numeric types to avoid server errors.
+ */
+export function mapToCreateAttributeParams(
+  attr: Attribute,
+  base: { databaseId: string; tableId: string }
+): CreateAttributeParams {
+  const type = String((attr as any).type || "").toLowerCase();
+  const required = !!(attr as any).required;
+  const array = !!(attr as any).array;
+  const xdefault = (attr as any).xdefault;
+  const encrypt = (attr as any).encrypted ?? (attr as any).encrypt;
+
+  // Numeric helpers
+  const rawMin = ensureNumber((attr as any).min);
+  const rawMax = ensureNumber((attr as any).max);
+  let min = rawMin;
+  let max = rawMax;
+  if (min !== undefined && max !== undefined && min >= max) {
+    // Swap to satisfy server-side validation
+    const tmp = min;
+    min = Math.min(min, max);
+    max = Math.max(tmp, max);
+    if (min === max) {
+      // If still equal, unset max to avoid error
+      max = undefined;
+    }
+  }
+
+  switch (type) {
+    case "string":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        size: (attr as any).size ?? 255,
+        required,
+        default: xdefault,
+        array,
+        encrypt: !!encrypt,
+      };
+
+    case "integer":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+        min,
+        max,
+      };
+
+    case "double":
+    case "float":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+        min,
+        max,
+      };
+
+    case "boolean":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+      };
+
+    case "datetime":
+    case "email":
+    case "ip":
+    case "url":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+      };
+
+    case "enum":
+      {
+        const elements = (attr as any).elements;
+        if (!Array.isArray(elements) || elements.length === 0) {
+          // Creating an enum without elements is invalid – fail fast with clear messaging
+          throw new Error(
+            `Enum attribute '${(attr as any).key}' requires a non-empty 'elements' array for creation`
+          );
+        }
+      }
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+        elements: (attr as any).elements,
+      };
+
+    case "relationship": {
+      // Relationship attributes require related collection and metadata
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        relatedCollection: (attr as any).relatedCollection,
+        relationType: (attr as any).relationType,
+        twoWay: (attr as any).twoWay,
+        twoWayKey: (attr as any).twoWayKey,
+        onDelete: (attr as any).onDelete,
+        side: (attr as any).side,
+      } as unknown as CreateAttributeParams;
+    }
+
+    default:
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+      } as CreateAttributeParams;
+  }
+}
+
+/**
+ * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
+ * Omits fields that are not explicitly provided, and guards enum updates
+ * so we never send an empty elements array (preserve existing on server).
+ */
+export function mapToUpdateAttributeParams(
+  attr: Attribute,
+  base: { databaseId: string; tableId: string }
+): UpdateAttributeParams {
+  const type = String((attr as any).type || "").toLowerCase();
+  const params: UpdateAttributeParams = {
+    databaseId: base.databaseId,
+    tableId: base.tableId,
+    key: (attr as any).key,
+  };
+
+  const setIfDefined = <K extends keyof UpdateAttributeParams>(
+    key: K,
+    value: UpdateAttributeParams[K]
+  ) => {
+    if (value !== undefined) (params as any)[key] = value;
+  };
+
+  // Common fields
+  setIfDefined("type", type);
+  setIfDefined("required", (attr as any).required);
+  // Only send default if explicitly provided and not on required
+  if (!(attr as any).required && (attr as any).xdefault !== undefined) {
+    setIfDefined("default", (attr as any).xdefault as any);
+  }
+  setIfDefined("array", (attr as any).array);
+  // encrypt only applies to string types
+  if (type === "string") setIfDefined("encrypt", (attr as any).encrypted ?? (attr as any).encrypt);
+
+  // Numeric normalization
+  const toNum = (n: any) => (n === null || n === undefined ? undefined : (Number(n)));
+  let min = toNum((attr as any).min);
+  let max = toNum((attr as any).max);
+  if (min !== undefined && max !== undefined && min >= max) {
+    const tmp = min;
+    min = Math.min(min, max);
+    max = Math.max(tmp, max);
+    if (min === max) max = undefined;
+  }
+
+  switch (type) {
+    case "string":
+      setIfDefined("size", (attr as any).size);
+      break;
+    case "integer":
+    case "float":
+    case "double":
+      setIfDefined("min", min);
+      setIfDefined("max", max);
+      break;
+    case "enum": {
+      const elements = (attr as any).elements;
+      if (Array.isArray(elements) && elements.length > 0) {
+        // Only include when non-empty; otherwise preserve existing on server
+        setIfDefined("elements", elements as string[]);
+      }
+      break;
+    }
+    case "relationship": {
+      setIfDefined("relatedCollection", (attr as any).relatedCollection);
+      setIfDefined("relationType", (attr as any).relationType);
+      setIfDefined("twoWay", (attr as any).twoWay);
+      setIfDefined("twoWayKey", (attr as any).twoWayKey);
+      setIfDefined("onDelete", (attr as any).onDelete);
+      break;
+    }
+  }
+
+  return params;
+}

package/src/shared/selectionDialogs.ts

@@ -244,12 +244,13 @@ export class SelectionDialogs {
         return; // Skip configured databases if only allowing new ones
       }
 
-      choices.push({
-        name,
-        value: database.$id,
-        short: database.name,
-        checked: defaultSelected.includes(database.$id) || (!allowNewOnly && isConfigured)
-      });
+      choices.push({
+        name,
+        value: database.$id,
+        short: database.name,
+        // Do not preselect anything unless explicitly provided
+        checked: defaultSelected.includes(database.$id)
+      });
     });
 
     if (choices.length === 0) {
@@ -327,12 +328,13 @@ export class SelectionDialogs {
         return; // Skip configured tables if only allowing new ones
       }
 
-      choices.push({
-        name,
-        value: table.$id,
-        short: table.name,
-        checked: defaultSelected.includes(table.$id) || (!allowNewOnly && isConfigured)
-      });
+      choices.push({
+        name,
+        value: table.$id,
+        short: table.name,
+        // Do not preselect anything unless explicitly provided
+        checked: defaultSelected.includes(table.$id)
+      });
     });
 
     if (choices.length === 0) {
@@ -436,12 +438,13 @@ export class SelectionDialogs {
               return; // Skip configured buckets if only allowing new ones
             }
 
-            choices.push({
-              name: `  ${name}`,
-              value: bucket.$id,
-              short: bucket.name,
-              checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
-            });
+            choices.push({
+              name: `  ${name}`,
+              value: bucket.$id,
+              short: bucket.name,
+              // Do not preselect anything unless explicitly provided
+              checked: defaultSelected.includes(bucket.$id)
+            });
           });
         }
       });
@@ -480,12 +483,13 @@ export class SelectionDialogs {
           return; // Skip configured buckets if only allowing new ones
         }
 
-        choices.push({
-          name,
-          value: bucket.$id,
-          short: bucket.name,
-          checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
-        });
+        choices.push({
+          name,
+          value: bucket.$id,
+          short: bucket.name,
+          // Do not preselect anything unless explicitly provided
+          checked: defaultSelected.includes(bucket.$id)
+        });
       });
     }
 
@@ -742,4 +746,4 @@ export class SelectionDialogs {
     MessageFormatter.success(message, { skipLogging: true });
     logger.info(`Selection dialog success: ${message}`);
   }
-}
+}

package/src/utils/configDiscovery.ts

@@ -1,6 +1,10 @@
 import path from "path";
 import fs from "fs";
-import { type CollectionCreate, type Collection } from "appwrite-utils";
+import {
+  CollectionCreateSchema,
+  type CollectionCreate,
+  type Collection
+} from "appwrite-utils";
 import { register } from "tsx/esm/api";
 import { pathToFileURL } from "node:url";
 import yaml from "js-yaml";
@@ -216,7 +220,7 @@ export const loadYamlCollection = (filePath: string): CollectionCreate | null =>
     const parsedCollection = YamlCollectionSchema.parse(yamlData);
 
     // Convert YAML collection to CollectionCreate format
-    const collection: CollectionCreate = {
+    const collectionInput: CollectionCreate = {
       name: parsedCollection.name,
       $id: parsedCollection.id || parsedCollection.name.toLowerCase().replace(/\s+/g, '_'),
       documentSecurity: parsedCollection.documentSecurity,
@@ -241,7 +245,7 @@ export const loadYamlCollection = (filePath: string): CollectionCreate | null =>
         twoWayKey: attr.twoWayKey,
         onDelete: attr.onDelete as any,
         side: attr.side as any,
-        encrypted: (attr as any).encrypt,
+        encrypt: (attr as any).encrypt,
         format: (attr as any).format
       })),
       indexes: parsedCollection.indexes.map(idx => ({
@@ -253,6 +257,8 @@ export const loadYamlCollection = (filePath: string): CollectionCreate | null =>
       importDefs: parsedCollection.importDefs && Array.isArray(parsedCollection.importDefs) && parsedCollection.importDefs.length > 0 ? parsedCollection.importDefs : []
     };
 
+    const collection = CollectionCreateSchema.parse(collectionInput);
+
     return collection;
   } catch (error) {
     MessageFormatter.error(`Error loading YAML collection from ${filePath}`, error as Error, { prefix: "Config" });

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)