appwrite-utils-cli 1.7.7 → 1.7.9

package/src/cli/commands/databaseCommands.ts

@@ -3,6 +3,9 @@ import chalk from "chalk";
 import { join } from "node:path";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
+import { SelectionDialogs } from "../../shared/selectionDialogs.js";
+import type { DatabaseSelection, BucketSelection } from "../../shared/selectionDialogs.js";
+import { logger } from "../../shared/logging.js";
 import { fetchAllDatabases } from "../../databases/methods.js";
 import { listBuckets } from "../../storage/methods.js";
 import { getFunction, downloadLatestFunctionDeployment } from "../../functions/methods.js";
@@ -12,23 +15,40 @@ export const databaseCommands = {
   async syncDb(cli: InteractiveCLI): Promise<void> {
     MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Database" });
 
-    const databases = await (cli as any).selectDatabases(
-      (cli as any).getLocalDatabases(),
-      chalk.blue("Select local databases to push:"),
-      true
-    );
+    try {
+      // Initialize controller
+      await (cli as any).controller!.init();
 
-    if (!databases.length) {
-      MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
-      return;
-    }
+      // Get available and configured databases
+      const availableDatabases = await fetchAllDatabases((cli as any).controller!.database!);
+      const configuredDatabases = (cli as any).controller!.config?.databases || [];
 
-    try {
-      // Loop through each database and prompt for collections specific to that database
-      for (const database of databases) {
-        MessageFormatter.info(`\n📦 Configuring push for database: ${database.name}`, { prefix: "Database" });
+      // Get local collections for selection
+      const localCollections = (cli as any).getLocalCollections();
+
+      // Push operations always use local configuration as source of truth
+
+      // Select databases
+      const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+        availableDatabases,
+        configuredDatabases,
+        { showSelectAll: true, allowNewOnly: false }
+      );
+
+      if (selectedDatabaseIds.length === 0) {
+        MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
+        return;
+      }
+
+      // Select tables/collections for each database using the existing method
+      const tableSelectionsMap = new Map<string, string[]>();
+      const availableTablesMap = new Map<string, any[]>();
 
-        const collections = await (cli as any).selectCollectionsAndTables(
+      for (const databaseId of selectedDatabaseIds) {
+        const database = availableDatabases.find(db => db.$id === databaseId)!;
+
+        // Use the existing selectCollectionsAndTables method
+        const selectedCollections = await (cli as any).selectCollectionsAndTables(
           database,
           (cli as any).controller!.database!,
           chalk.blue(`Select collections/tables to push to "${database.name}":`),
@@ -36,19 +56,93 @@ export const databaseCommands = {
           true   // prefer local
         );
 
-        if (collections.length === 0) {
+        // Map selected collections to table IDs
+        const selectedTableIds = selectedCollections.map((c: any) => c.$id || c.id);
+
+        // Store selections
+        tableSelectionsMap.set(databaseId, selectedTableIds);
+        availableTablesMap.set(databaseId, selectedCollections);
+
+        if (selectedCollections.length === 0) {
           MessageFormatter.warning(`No collections selected for database "${database.name}". Skipping.`, { prefix: "Database" });
           continue;
         }
+      }
 
-        // Push selected collections to this specific database
-        await (cli as any).controller!.syncDb([database], collections);
-        MessageFormatter.success(
-          `Pushed ${collections.length} collection(s) to database "${database.name}"`,
-          { prefix: "Database" }
-        );
+      // Ask if user wants to select buckets
+      const { selectBuckets } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "selectBuckets",
+          message: "Do you want to select storage buckets to sync as well?",
+          default: false,
+        },
+      ]);
+
+      let bucketSelections: BucketSelection[] = [];
+
+      if (selectBuckets) {
+        // Get available and configured buckets
+        try {
+          const availableBucketsResponse = await listBuckets((cli as any).controller!.storage!);
+          const availableBuckets = availableBucketsResponse.buckets || [];
+          const configuredBuckets = (cli as any).controller!.config?.buckets || [];
+
+          if (availableBuckets.length === 0) {
+            MessageFormatter.warning("No storage buckets available in remote instance.", { prefix: "Database" });
+          } else {
+            // Select buckets using SelectionDialogs
+            const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+              selectedDatabaseIds,
+              availableBuckets,
+              configuredBuckets,
+              { showSelectAll: true, groupByDatabase: true }
+            );
+
+            if (selectedBucketIds.length > 0) {
+              // Create BucketSelection objects
+              bucketSelections = SelectionDialogs.createBucketSelection(
+                selectedBucketIds,
+                availableBuckets,
+                configuredBuckets,
+                availableDatabases
+              );
+
+              MessageFormatter.info(`Selected ${bucketSelections.length} storage bucket(s)`, { prefix: "Database" });
+            }
+          }
+        } catch (error) {
+          MessageFormatter.warning("Failed to fetch storage buckets. Continuing with databases only.", { prefix: "Database" });
+          logger.warn("Storage bucket fetch failed during syncDb", { error: error instanceof Error ? error.message : String(error) });
+        }
       }
 
+      // Create DatabaseSelection objects
+      const databaseSelections = SelectionDialogs.createDatabaseSelection(
+        selectedDatabaseIds,
+        availableDatabases,
+        tableSelectionsMap,
+        configuredDatabases,
+        availableTablesMap
+      );
+
+      // Show confirmation summary
+      const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+        databaseSelections,
+        bucketSelections
+      );
+
+      const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'push');
+
+      if (!confirmed) {
+        MessageFormatter.info("Push operation cancelled by user", { prefix: "Database" });
+        return;
+      }
+
+      // Perform selective push using the controller
+      MessageFormatter.progress("Starting selective push...", { prefix: "Database" });
+      await (cli as any).controller!.selectivePush(databaseSelections, bucketSelections);
+
       MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });
 
       // Then handle functions if requested
@@ -104,23 +198,28 @@ export const databaseCommands = {
         (cli as any).controller!.database!
       );
 
-      // Use the controller's synchronizeConfigurations method which handles collections properly
-      MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
-      await (cli as any).controller!.synchronizeConfigurations(remoteDatabases);
-
-      // Also configure buckets for any new databases
+      // First, prepare the combined database list for bucket configuration
       const localDatabases = (cli as any).controller!.config?.databases || [];
-      const updatedConfig = await (cli as any).configureBuckets({
+      const allDatabases = [
+        ...localDatabases,
+        ...remoteDatabases.filter(
+          (rd: any) => !localDatabases.some((ld: any) => ld.name === rd.name)
+        ),
+      ];
+
+      // Configure buckets FIRST to get user selections before writing config
+      MessageFormatter.progress("Configuring storage buckets...", { prefix: "Buckets" });
+      const configWithBuckets = await (cli as any).configureBuckets({
         ...(cli as any).controller!.config!,
-        databases: [
-          ...localDatabases,
-          ...remoteDatabases.filter(
-            (rd: any) => !localDatabases.some((ld: any) => ld.name === rd.name)
-          ),
-        ],
+        databases: allDatabases,
       });
 
-      (cli as any).controller!.config = updatedConfig;
+      // Update controller config with bucket selections
+      (cli as any).controller!.config = configWithBuckets;
+
+      // Now synchronize configurations with the updated config that includes bucket selections
+      MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
+      await (cli as any).controller!.synchronizeConfigurations(remoteDatabases, configWithBuckets);
     }
 
     // Then sync functions

package/src/config/services/ConfigLoaderService.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import path from "path";
+import { resolve as resolvePath, dirname, isAbsolute } from "node:path";
 import yaml from "js-yaml";
 import { register } from "tsx/esm/api";
 import { pathToFileURL } from "node:url";
@@ -19,6 +20,7 @@ import {
   type CollectionDiscoveryResult,
   type TableDiscoveryResult,
 } from "../../utils/configDiscovery.js";
+import { expandTildePath } from "../../functions/pathResolution.js";
 
 /**
  * Options for loading collections or tables
@@ -51,6 +53,35 @@ export interface CollectionLoadOptions {
  * - Validates and normalizes configuration data
  */
 export class ConfigLoaderService {
+  /**
+   * Normalizes function dirPath to absolute path
+   * @param func Function configuration object
+   * @param configDir Directory containing the config file
+   * @returns Function with normalized dirPath
+   */
+  private normalizeFunctionPath(func: any, configDir: string): any {
+    if (!func.dirPath) {
+      return func;
+    }
+
+    // Expand tilde first
+    const expandedPath = expandTildePath(func.dirPath);
+
+    // If already absolute, return as-is
+    if (isAbsolute(expandedPath)) {
+      return {
+        ...func,
+        dirPath: expandedPath
+      };
+    }
+
+    // Resolve relative to config directory
+    return {
+      ...func,
+      dirPath: resolvePath(configDir, expandedPath)
+    };
+  }
+
   /**
    * Loads configuration from a discovered path, auto-detecting the type
    * @param configPath Path to the configuration file
@@ -78,6 +109,13 @@ export class ConfigLoaderService {
         );
       }
 
+      const configDir = path.dirname(configPath);
+
+      // Normalize function paths
+      const normalizedFunctions = partialConfig.functions
+        ? partialConfig.functions.map(func => this.normalizeFunctionPath(func, configDir))
+        : [];
+
       return {
         appwriteEndpoint: partialConfig.appwriteEndpoint,
         appwriteProject: partialConfig.appwriteProject,
@@ -105,7 +143,7 @@ export class ConfigLoaderService {
         },
         databases: partialConfig.databases || [],
         buckets: partialConfig.buckets || [],
-        functions: partialConfig.functions || [],
+        functions: normalizedFunctions,
         collections: partialConfig.collections || [],
         sessionCookie: partialConfig.sessionCookie,
         authMethod: partialConfig.authMethod || "auto",
@@ -155,6 +193,13 @@ export class ConfigLoaderService {
 
       // Load collections and tables from their respective directories
       const configDir = path.dirname(yamlPath);
+
+      // Normalize function paths
+      if (config.functions) {
+        config.functions = config.functions.map(func =>
+          this.normalizeFunctionPath(func, configDir)
+        );
+      }
       const collectionsDir = path.join(configDir, config.schemaConfig?.collectionsDirectory || "collections");
       const tablesDir = path.join(configDir, config.schemaConfig?.tablesDirectory || "tables");
 
@@ -248,6 +293,14 @@ export class ConfigLoaderService {
         throw new Error(`Failed to load TypeScript config from: ${tsPath}`);
       }
 
+      // Normalize function paths
+      const configDir = path.dirname(tsPath);
+      if (config.functions) {
+        config.functions = config.functions.map(func =>
+          this.normalizeFunctionPath(func, configDir)
+        );
+      }
+
       MessageFormatter.success(`Loaded TypeScript config from: ${tsPath}`, {
         prefix: "Config",
       });
@@ -292,6 +345,14 @@ export class ConfigLoaderService {
         appwriteConfig.collections = collections;
       }
 
+      // Normalize function paths
+      const configDir = path.dirname(jsonPath);
+      if (appwriteConfig.functions) {
+        appwriteConfig.functions = appwriteConfig.functions.map(func =>
+          this.normalizeFunctionPath(func, configDir)
+        );
+      }
+
       MessageFormatter.success(`Loaded project config from: ${jsonPath}`, {
         prefix: "Config",
       });

package/src/functions/deployments.ts

@@ -16,30 +16,7 @@ import {
 } from "./methods.js";
 import ignore from "ignore";
 import { MessageFormatter } from "../shared/messageFormatter.js";
-
-const findFunctionDirectory = (
-  basePath: string,
-  functionName: string
-): string | undefined => {
-  const normalizedName = functionName.toLowerCase().replace(/\s+/g, "-");
-  const dirs = fs.readdirSync(basePath, { withFileTypes: true });
-
-  for (const dir of dirs) {
-    if (dir.isDirectory()) {
-      const fullPath = join(basePath, dir.name);
-      if (dir.name.toLowerCase() === normalizedName) {
-        return fullPath;
-      }
-
-      const nestedResult = findFunctionDirectory(fullPath, functionName);
-      if (nestedResult) {
-        return nestedResult;
-      }
-    }
-  }
-
-  return undefined;
-};
+import { resolveFunctionDirectory, validateFunctionDirectory } from './pathResolution.js';
 
 export const deployFunction = async (
   client: Client,
@@ -183,18 +160,16 @@ export const deployLocalFunction = async (
     functionExists = false;
   }
 
-  const resolvedPath =
-    functionPath ||
-    functionConfig.dirPath ||
-    findFunctionDirectory(process.cwd(), functionName) ||
-    join(
-      process.cwd(),
-      "functions",
-      functionName.toLowerCase().replace(/\s+/g, "-")
-    );
+  const configDirPath = process.cwd(); // TODO: This should be passed from caller
+  const resolvedPath = resolveFunctionDirectory(
+    functionName,
+    configDirPath,
+    functionConfig.dirPath,
+    functionPath
+  );
 
-  if (!fs.existsSync(resolvedPath)) {
-    throw new Error(`Function directory not found at ${resolvedPath}`);
+  if (!validateFunctionDirectory(resolvedPath)) {
+    throw new Error(`Function directory is invalid or missing required files: ${resolvedPath}`);
   }
 
   if (functionConfig.predeployCommands?.length) {

package/src/functions/methods.ts

@@ -17,6 +17,7 @@ import {
 import chalk from "chalk";
 import { extract as extractTar } from "tar";
 import { MessageFormatter } from "../shared/messageFormatter.js";
+import { expandTildePath, normalizeFunctionName } from "./pathResolution.js";
 
 /**
  * Validates and filters events array for Appwrite functions
@@ -72,7 +73,7 @@ export const downloadLatestFunctionDeployment = async (
   // Create function directory using provided basePath
   const functionDir = join(
     basePath,
-    functionInfo.name.toLowerCase().replace(/\s+/g, "-")
+    normalizeFunctionName(functionInfo.name)
   );
   await fs.promises.mkdir(functionDir, { recursive: true });
 
@@ -219,7 +220,8 @@ export const createFunctionTemplate = async (
   functionName: string,
   basePath: string = "./functions"
 ) => {
-  const functionPath = join(basePath, functionName);
+  const expandedBasePath = expandTildePath(basePath);
+  const functionPath = join(expandedBasePath, functionName);
   const currentFileUrl = import.meta.url;
   const currentDir = dirname(fileURLToPath(currentFileUrl));
   const templatesPath = join(currentDir, "templates", templateType);

package/src/functions/pathResolution.ts

@@ -0,0 +1,227 @@
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { join, resolve, isAbsolute } from 'node:path';
+import { homedir } from 'node:os';
+import { MessageFormatter } from '../shared/messageFormatter.js';
+import { logger } from '../shared/logging.js';
+
+/**
+ * Expands tilde (~) in paths to the user's home directory
+ * @param pathStr - Path string that may contain ~
+ * @returns Expanded path with home directory
+ */
+export function expandTildePath(pathStr: string): string {
+  if (!pathStr) return pathStr;
+
+  if (pathStr.startsWith('~/') || pathStr === '~') {
+    const expandedPath = pathStr.replace(/^~(?=$|\/|\\)/, homedir());
+    logger.debug('Expanded tilde path', { original: pathStr, expanded: expandedPath });
+    return expandedPath;
+  }
+
+  return pathStr;
+}
+
+/**
+ * Normalizes function name to standard format (lowercase, dashes instead of spaces)
+ * @param name - Function name to normalize
+ * @returns Normalized function name
+ */
+export function normalizeFunctionName(name: string): string {
+  if (!name) return name;
+
+  const normalized = name.toLowerCase().replace(/\s+/g, '-');
+
+  if (normalized !== name) {
+    logger.debug('Normalized function name', { original: name, normalized });
+  }
+
+  return normalized;
+}
+
+/**
+ * Validates that a directory exists and contains function markers
+ * @param dirPath - Directory path to validate
+ * @returns True if directory is a valid function directory
+ */
+export function validateFunctionDirectory(dirPath: string): boolean {
+  try {
+    // Check if directory exists
+    if (!existsSync(dirPath)) {
+      logger.debug('Directory does not exist', { dirPath });
+      return false;
+    }
+
+    // Check if it's actually a directory
+    const stats = statSync(dirPath);
+    if (!stats.isDirectory()) {
+      logger.debug('Path is not a directory', { dirPath });
+      return false;
+    }
+
+    // Check for function markers
+    const contents = readdirSync(dirPath);
+    const hasPackageJson = contents.includes('package.json');
+    const hasPyprojectToml = contents.includes('pyproject.toml');
+    const hasSrcDir = contents.includes('src');
+
+    const isValid = hasPackageJson || hasPyprojectToml || hasSrcDir;
+
+    logger.debug('Function directory validation', {
+      dirPath,
+      isValid,
+      markers: {
+        hasPackageJson,
+        hasPyprojectToml,
+        hasSrcDir
+      }
+    });
+
+    return isValid;
+  } catch (error) {
+    logger.debug('Error validating function directory', {
+      dirPath,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+
+/**
+ * Helper function to search for function in standard locations
+ * @param configDirPath - Directory where config file is located
+ * @param normalizedName - Normalized function name
+ * @returns First valid function directory path or undefined
+ */
+export function findFunctionInStandardLocations(
+  configDirPath: string,
+  normalizedName: string
+): string | undefined {
+  const searchPaths = [
+    // Same directory as config
+    join(configDirPath, 'functions', normalizedName),
+    // Parent directory of config
+    join(configDirPath, '..', 'functions', normalizedName),
+    // Current working directory
+    join(process.cwd(), 'functions', normalizedName),
+  ];
+
+  logger.debug('Searching for function in standard locations', {
+    normalizedName,
+    configDirPath,
+    searchPaths
+  });
+
+  for (const searchPath of searchPaths) {
+    const resolvedPath = resolve(searchPath);
+    logger.debug('Checking search path', { searchPath, resolvedPath });
+
+    if (validateFunctionDirectory(resolvedPath)) {
+      logger.debug('Found function in standard location', { resolvedPath });
+      return resolvedPath;
+    }
+  }
+
+  logger.debug('Function not found in any standard location', { normalizedName });
+  return undefined;
+}
+
+/**
+ * Resolves the absolute path to a function directory
+ * Handles multiple resolution strategies with proper priority
+ *
+ * @param functionName - Name of the function
+ * @param configDirPath - Directory where config file is located
+ * @param dirPath - Optional explicit dirPath from config
+ * @param explicitPath - Optional path passed as parameter (highest priority)
+ * @returns Absolute path to the function directory
+ * @throws Error if function directory cannot be found or is invalid
+ */
+export function resolveFunctionDirectory(
+  functionName: string,
+  configDirPath: string,
+  dirPath?: string,
+  explicitPath?: string
+): string {
+  logger.debug('Resolving function directory', {
+    functionName,
+    configDirPath,
+    dirPath,
+    explicitPath
+  });
+
+  const normalizedName = normalizeFunctionName(functionName);
+
+  // Priority 1: Explicit path parameter (highest priority)
+  if (explicitPath) {
+    logger.debug('Using explicit path parameter');
+    const expandedPath = expandTildePath(explicitPath);
+    const resolvedPath = isAbsolute(expandedPath)
+      ? expandedPath
+      : resolve(process.cwd(), expandedPath);
+
+    if (!validateFunctionDirectory(resolvedPath)) {
+      const errorMsg = `Explicit path is not a valid function directory: ${resolvedPath}`;
+      logger.error(errorMsg);
+      MessageFormatter.error('Invalid function directory', errorMsg, { prefix: 'Path Resolution' });
+      throw new Error(errorMsg);
+    }
+
+    logger.debug('Resolved using explicit path', { resolvedPath });
+    MessageFormatter.debug(`Resolved function directory using explicit path: ${resolvedPath}`, undefined, { prefix: 'Path Resolution' });
+    return resolvedPath;
+  }
+
+  // Priority 2: dirPath from config (relative to config location)
+  if (dirPath) {
+    logger.debug('Using dirPath from config');
+    const expandedPath = expandTildePath(dirPath);
+    const resolvedPath = isAbsolute(expandedPath)
+      ? expandedPath
+      : resolve(configDirPath, expandedPath);
+
+    if (!validateFunctionDirectory(resolvedPath)) {
+      const errorMsg = `Config dirPath is not a valid function directory: ${resolvedPath}`;
+      logger.error(errorMsg);
+      MessageFormatter.error('Invalid function directory', errorMsg, { prefix: 'Path Resolution' });
+      throw new Error(errorMsg);
+    }
+
+    logger.debug('Resolved using config dirPath', { resolvedPath });
+    MessageFormatter.debug(`Resolved function directory using config dirPath: ${resolvedPath}`, undefined, { prefix: 'Path Resolution' });
+    return resolvedPath;
+  }
+
+  // Priority 3: Search standard locations
+  logger.debug('Searching standard locations for function');
+  const foundPath = findFunctionInStandardLocations(configDirPath, normalizedName);
+
+  if (foundPath) {
+    logger.debug('Resolved using standard location search', { foundPath });
+    MessageFormatter.debug(`Found function directory in standard location: ${foundPath}`, undefined, { prefix: 'Path Resolution' });
+    return foundPath;
+  }
+
+  // Priority 4: Not found - throw error
+  const searchedLocations = [
+    join(configDirPath, 'functions', normalizedName),
+    join(configDirPath, '..', 'functions', normalizedName),
+    join(process.cwd(), 'functions', normalizedName),
+  ];
+
+  const errorMsg = `Function directory not found for '${functionName}' (normalized: '${normalizedName}'). ` +
+    `Searched locations:\n${searchedLocations.map(p => `  - ${p}`).join('\n')}`;
+
+  logger.error('Function directory not found', {
+    functionName,
+    normalizedName,
+    searchedLocations
+  });
+
+  MessageFormatter.error(
+    'Function directory not found',
+    errorMsg,
+    { prefix: 'Path Resolution' }
+  );
+
+  throw new Error(errorMsg);
+}