appwrite-utils-cli 1.7.8 → 1.8.1

package/src/functions/fnConfigDiscovery.ts

@@ -0,0 +1,103 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { homedir } from 'node:os';
+import { AppwriteFunctionSchema, type AppwriteFunction } from 'appwrite-utils';
+import { shouldIgnoreDirectory } from '../utils/directoryUtils.js';
+import { MessageFormatter } from '../shared/messageFormatter.js';
+
+function findGitRoot(startDir: string): string {
+  let dir = path.resolve(startDir);
+  while (dir !== path.parse(dir).root) {
+    if (fs.existsSync(path.join(dir, '.git'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.resolve(startDir);
+}
+
+function expandTilde(p: string): string {
+  if (!p) return p;
+  if (p === '~' || p.startsWith('~/')) return p.replace(/^~(?=$|\/|\\)/, homedir());
+  return p;
+}
+
+export function discoverFnConfigs(startDir: string): AppwriteFunction[] {
+  const root = findGitRoot(startDir);
+  const results: AppwriteFunction[] = [];
+
+  const visit = (dir: string, depth = 0) => {
+    if (depth > 5) return; // cap depth
+    const base = path.basename(dir);
+    if (shouldIgnoreDirectory(base)) return;
+    let entries: fs.Dirent[] = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+    // Check for .fnconfig.yaml / .fnconfig.yml
+    for (const fname of ['.fnconfig.yaml', '.fnconfig.yml']) {
+      const cfgPath = path.join(dir, fname);
+      if (fs.existsSync(cfgPath)) {
+        try {
+          const raw = fs.readFileSync(cfgPath, 'utf8');
+          const data = yaml.load(raw) as any;
+          const parsed = AppwriteFunctionSchema.parse({
+            $id: data.id || data.$id,
+            name: data.name,
+            runtime: data.runtime,
+            execute: data.execute || [],
+            events: data.events || [],
+            schedule: data.schedule,
+            timeout: data.timeout,
+            enabled: data.enabled,
+            logging: data.logging,
+            entrypoint: data.entrypoint,
+            commands: data.commands,
+            scopes: data.scopes,
+            installationId: data.installationId,
+            providerRepositoryId: data.providerRepositoryId,
+            providerBranch: data.providerBranch,
+            providerSilentMode: data.providerSilentMode,
+            providerRootDirectory: data.providerRootDirectory,
+            templateRepository: data.templateRepository,
+            templateOwner: data.templateOwner,
+            templateRootDirectory: data.templateRootDirectory,
+            templateVersion: data.templateVersion,
+            specification: data.specification,
+            dirPath: data.dirPath,
+            predeployCommands: data.predeployCommands,
+            deployDir: data.deployDir,
+            ignore: data.ignore,
+          });
+
+          // Resolve dirPath relative to the config file directory
+          let dirPath = parsed.dirPath || '.';
+          dirPath = expandTilde(dirPath);
+          if (!path.isAbsolute(dirPath)) dirPath = path.resolve(path.dirname(cfgPath), dirPath);
+          const merged: AppwriteFunction = { ...parsed, dirPath };
+          results.push(merged);
+        } catch (e) {
+          MessageFormatter.warning(`Failed to parse ${cfgPath}: ${e instanceof Error ? e.message : String(e)}`, { prefix: 'Functions' });
+        }
+      }
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) visit(path.join(dir, entry.name), depth + 1);
+    }
+  };
+
+  visit(root, 0);
+  return results;
+}
+
+export function mergeDiscoveredFunctions(
+  central: AppwriteFunction[] = [],
+  discovered: AppwriteFunction[] = []
+): AppwriteFunction[] {
+  const map = new Map<string, AppwriteFunction>();
+  for (const f of central) if (f?.$id) map.set(f.$id, f);
+  for (const f of discovered) if (f?.$id) map.set(f.$id, f); // discovered overrides
+  return Array.from(map.values());
+}
+

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/interactiveCLI.ts

@@ -10,6 +10,7 @@ import {
   Compression,
   Query,
   Functions,
+  DatabaseType,
 } from "node-appwrite";
 import {
   PermissionToAppwritePermission,
@@ -232,10 +233,10 @@ export class InteractiveCLI {
     const configDatabases = this.getLocalDatabases();
     const allDatabases = [...databases, ...configDatabases]
       .reduce((acc, db) => {
-        // Local config takes precedence - if a database with same name exists, use local version
-        const existingIndex = acc.findIndex((d) => d.name === db.name);
+        // Local config takes precedence - if a database with same name or ID exists, use local version
+        const existingIndex = acc.findIndex((d) => d.name === db.name || d.$id === db.$id);
         if (existingIndex >= 0) {
-          if (configDatabases.some((cdb) => cdb.name === db.name)) {
+          if (configDatabases.some((cdb) => cdb.name === db.name || cdb.$id === db.$id)) {
             acc[existingIndex] = db; // Replace with local version
           }
         } else {
@@ -246,10 +247,10 @@ export class InteractiveCLI {
 
     const hasLocalAndRemote =
       allDatabases.some((db) =>
-        configDatabases.some((c) => c.name === db.name)
+        configDatabases.some((c) => c.name === db.name || c.$id === db.$id)
       ) &&
       allDatabases.some(
-        (db) => !configDatabases.some((c) => c.name === db.name)
+        (db) => !configDatabases.some((c) => c.name === db.name || c.$id === db.$id)
       );
 
     const choices = allDatabases
@@ -258,7 +259,7 @@ export class InteractiveCLI {
         name:
           db.name +
           (hasLocalAndRemote
-            ? configDatabases.some((c) => c.name === db.name)
+            ? configDatabases.some((c) => c.name === db.name || c.$id === db.$id)
               ? " (Local)"
               : " (Remote)"
             : ""),
@@ -311,7 +312,7 @@ export class InteractiveCLI {
     let allCollections = preferLocal
       ? remoteCollections.reduce(
           (acc, remoteCollection) => {
-            if (!acc.some((c) => c.name === remoteCollection.name)) {
+            if (!acc.some((c) => c.name === remoteCollection.name || c.$id === remoteCollection.$id)) {
               acc.push(remoteCollection);
             }
             return acc;
@@ -321,7 +322,7 @@ export class InteractiveCLI {
       : [
           ...remoteCollections,
           ...configCollections.filter(
-            (c) => !remoteCollections.some((rc) => rc.name === c.name)
+            (c) => !remoteCollections.some((rc) => rc.name === c.name || rc.$id === c.$id)
           ),
         ];
 
@@ -329,7 +330,7 @@ export class InteractiveCLI {
       // Show collections that EITHER exist in the remote database OR have matching local databaseId metadata
       allCollections = allCollections.filter((c: any) => {
         // Include if it exists remotely in this database
-        const existsInRemoteDb = remoteCollections.some((rc) => rc.name === c.name);
+        const existsInRemoteDb = remoteCollections.some((rc) => rc.name === c.name || rc.$id === c.$id);
 
         // Include if local metadata claims it belongs to this database
         const hasMatchingLocalMetadata = c.databaseId === database.$id;
@@ -345,10 +346,10 @@ export class InteractiveCLI {
 
     const hasLocalAndRemote =
       allCollections.some((coll) =>
-        configCollections.some((c) => c.name === coll.name)
+        configCollections.some((c) => c.name === coll.name || c.$id === coll.$id)
       ) &&
       allCollections.some(
-        (coll) => !configCollections.some((c) => c.name === coll.name)
+        (coll) => !configCollections.some((c) => c.name === coll.name || c.$id === coll.$id)
       );
 
     // Enhanced choice display with type indicators
@@ -365,7 +366,7 @@ export class InteractiveCLI {
         return a.name.localeCompare(b.name);
       })
       .map((collection) => {
-        const localCollection = configCollections.find((c) => c.name === collection.name);
+        const localCollection = configCollections.find((c) => c.name === collection.name || c.$id === collection.$id);
         const isLocal = !!localCollection;
         const isTable = localCollection?._isFromTablesDir || (collection as any)._isFromTablesDir || false;
         const sourceFolder = localCollection?._sourceFolder || (collection as any)._sourceFolder || 'collections';
@@ -447,12 +448,15 @@ export class InteractiveCLI {
       MessageFormatter.info(`📊 ${tablesCount} tables available from tables/ folder`, { prefix: "Collections" });
     }
 
-    // Ask user if they want to filter by database or show all
-    const { filterChoice } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "filterChoice",
-        message: chalk.blue("How would you like to view collections/tables?"),
+    // Show current database context clearly before view mode selection
+    MessageFormatter.info(`DB: ${database.name}`, { prefix: "Collections" });
+
+    // Ask user if they want to filter by database or show all
+    const { filterChoice } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "filterChoice",
+        message: chalk.blue("How would you like to view collections/tables?"),
         choices: [
           {
             name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
@@ -629,7 +633,7 @@ export class InteractiveCLI {
     const allFunctions = [
       ...localFunctions,
       ...remoteFunctions.functions.filter(
-        (rf: any) => !localFunctions.some((lf) => lf.name === rf.name)
+        (rf: any) => !localFunctions.some((lf) => lf.name === rf.name || lf.$id === rf.$id)
       ),
     ];
 
@@ -640,7 +644,7 @@ export class InteractiveCLI {
         message,
         choices: allFunctions.map((f) => ({
           name: `${f.name} (${f.$id})${
-            localFunctions.some((lf) => lf.name === f.name)
+            localFunctions.some((lf) => lf.name === f.name || lf.$id === f.$id)
               ? " (Local)"
               : " (Remote)"
           }`,
@@ -980,6 +984,7 @@ export class InteractiveCLI {
       $updatedAt: DateTime.now().toISO(),
       name: db.name,
       enabled: true,
+      type: "tablesdb" as DatabaseType,
     }));
   }