appwrite-utils-cli 1.7.8 → 1.7.9

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

package/src/main.ts

@@ -149,14 +149,14 @@ async function performEnhancedSync(
           bucketSelections
         );
 
-        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
         if (!confirmed) {
-          MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+          MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
           return null;
         }
 
-        // Perform sync with existing configuration
-        await controller.selectiveSync(databaseSelections, bucketSelections);
+        // Perform sync with existing configuration (pull from remote)
+        await controller.selectivePull(databaseSelections, bucketSelections);
         return selectionSummary;
       }
     }
@@ -275,14 +275,14 @@ async function performEnhancedSync(
       bucketSelections
     );
 
-    const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+    const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
     if (!confirmed) {
-      MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+      MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
       return null;
     }
 
-    // Perform the selective sync
-    await controller.selectiveSync(databaseSelections, bucketSelections);
+    // Perform the selective sync (pull from remote)
+    await controller.selectivePull(databaseSelections, bucketSelections);
 
     MessageFormatter.success("Enhanced sync completed successfully", { prefix: "Sync" });
     return selectionSummary;

package/src/shared/selectionDialogs.ts

@@ -520,8 +520,37 @@ export class SelectionDialogs {
   /**
    * Shows final confirmation dialog with sync selection summary
    */
-  static async confirmSyncSelection(selectionSummary: SyncSelectionSummary): Promise<boolean> {
-    MessageFormatter.banner("Sync Selection Summary", "Review your selections before proceeding");
+  static async confirmSyncSelection(
+    selectionSummary: SyncSelectionSummary,
+    operationType: 'push' | 'pull' | 'sync' = 'sync'
+  ): Promise<boolean> {
+    const labels = {
+      push: {
+        banner: "Push Selection Summary",
+        subtitle: "Review selections before pushing to Appwrite",
+        confirm: "Proceed with push operation?",
+        success: "Push operation confirmed.",
+        cancel: "Push operation cancelled."
+      },
+      pull: {
+        banner: "Pull Selection Summary",
+        subtitle: "Review selections before pulling from Appwrite",
+        confirm: "Proceed with pull operation?",
+        success: "Pull operation confirmed.",
+        cancel: "Pull operation cancelled."
+      },
+      sync: {
+        banner: "Sync Selection Summary",
+        subtitle: "Review your selections before proceeding",
+        confirm: "Proceed with sync operation?",
+        success: "Sync operation confirmed.",
+        cancel: "Sync operation cancelled."
+      }
+    };
+
+    const label = labels[operationType];
+
+    MessageFormatter.banner(label.banner, label.subtitle);
 
     // Database summary
     console.log(chalk.bold.cyan("\n📊 Databases:"));
@@ -563,20 +592,20 @@ export class SelectionDialogs {
     const { confirmed } = await inquirer.prompt([{
       type: 'confirm',
       name: 'confirmed',
-      message: chalk.green.bold('Proceed with sync operation?'),
+      message: chalk.green.bold(label.confirm),
       default: true
     }]);
 
     if (confirmed) {
-      MessageFormatter.success("Sync operation confirmed.", { skipLogging: true });
-      logger.info("Sync selection confirmed", {
+      MessageFormatter.success(label.success, { skipLogging: true });
+      logger.info(`${operationType} selection confirmed`, {
         databases: selectionSummary.totalDatabases,
         tables: selectionSummary.totalTables,
         buckets: selectionSummary.totalBuckets
       });
     } else {
-      MessageFormatter.warning("Sync operation cancelled.", { skipLogging: true });
-      logger.info("Sync selection cancelled by user");
+      MessageFormatter.warning(label.cancel, { skipLogging: true });
+      logger.info(`${operationType} selection cancelled by user`);
     }
 
     return confirmed;