appwrite-utils-cli 1.7.8 → 1.7.9

package/dist/cli/commands/databaseCommands.js

@@ -19,10 +19,9 @@ export const databaseCommands = {
             const configuredDatabases = cli.controller.config?.databases || [];
             // Get local collections for selection
             const localCollections = cli.getLocalCollections();
-            // Prompt about existing configuration
-            const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+            // Push operations always use local configuration as source of truth
             // Select databases
-            const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, { showSelectAll: true, allowNewOnly: !syncExisting });
+            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;
@@ -84,14 +83,14 @@ export const databaseCommands = {
             const databaseSelections = SelectionDialogs.createDatabaseSelection(selectedDatabaseIds, availableDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap);
             // Show confirmation summary
             const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
-            const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+            const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'push');
             if (!confirmed) {
-                MessageFormatter.info("Sync operation cancelled by user", { prefix: "Database" });
+                MessageFormatter.info("Push operation cancelled by user", { prefix: "Database" });
                 return;
             }
-            // Perform selective sync using the controller
-            MessageFormatter.progress("Starting selective sync...", { prefix: "Database" });
-            await cli.controller.selectiveSync(databaseSelections, bucketSelections);
+            // Perform selective push using the controller
+            MessageFormatter.progress("Starting selective push...", { prefix: "Database" });
+            await cli.controller.selectivePush(databaseSelections, bucketSelections);
             MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });
             // Then handle functions if requested
             const { syncFunctions } = await inquirer.prompt([

package/dist/config/services/ConfigLoaderService.d.ts

@@ -30,6 +30,13 @@ export interface CollectionLoadOptions {
  * - Validates and normalizes configuration data
  */
 export declare 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;
     /**
      * Loads configuration from a discovered path, auto-detecting the type
      * @param configPath Path to the configuration file

package/dist/config/services/ConfigLoaderService.js

@@ -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";
@@ -8,6 +9,7 @@ import { normalizeYamlData } from "../../utils/yamlConverter.js";
 import { loadYamlConfig } from "../yamlConfig.js";
 import { loadAppwriteProjectConfig, projectConfigToAppwriteConfig, getCollectionsFromProject } from "../../utils/projectConfig.js";
 import { loadYamlCollection, loadYamlTable, } from "../../utils/configDiscovery.js";
+import { expandTildePath } from "../../functions/pathResolution.js";
 /**
  * Service for loading and parsing Appwrite configuration files.
  *
@@ -25,6 +27,31 @@ import { loadYamlCollection, loadYamlTable, } from "../../utils/configDiscovery.
  * - 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
+     */
+    normalizeFunctionPath(func, configDir) {
+        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
@@ -46,6 +73,11 @@ export class ConfigLoaderService {
             if (!partialConfig.appwriteEndpoint || !partialConfig.appwriteProject) {
                 throw new Error("JSON project config must contain at minimum 'endpoint' and 'projectId' fields");
             }
+            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,
@@ -73,7 +105,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",
@@ -114,6 +146,10 @@ 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");
             // Detect API mode to determine priority order
@@ -175,6 +211,11 @@ export class ConfigLoaderService {
             if (!config) {
                 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",
             });
@@ -210,6 +251,11 @@ export class ConfigLoaderService {
             if (collections.length > 0) {
                 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/dist/functions/deployments.js

@@ -11,23 +11,7 @@ import { execSync } from "child_process";
 import { createFunction, getFunction, updateFunction, updateFunctionSpecifications, } from "./methods.js";
 import ignore from "ignore";
 import { MessageFormatter } from "../shared/messageFormatter.js";
-const findFunctionDirectory = (basePath, functionName) => {
-    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, functionId, codePath, activate = true, entrypoint = "index.js", commands = "npm install", ignored = [
     "node_modules",
     ".git",
@@ -123,12 +107,10 @@ export const deployLocalFunction = async (client, functionName, functionConfig,
     catch (error) {
         functionExists = false;
     }
-    const resolvedPath = functionPath ||
-        functionConfig.dirPath ||
-        findFunctionDirectory(process.cwd(), functionName) ||
-        join(process.cwd(), "functions", functionName.toLowerCase().replace(/\s+/g, "-"));
-    if (!fs.existsSync(resolvedPath)) {
-        throw new Error(`Function directory not found at ${resolvedPath}`);
+    const configDirPath = process.cwd(); // TODO: This should be passed from caller
+    const resolvedPath = resolveFunctionDirectory(functionName, configDirPath, functionConfig.dirPath, functionPath);
+    if (!validateFunctionDirectory(resolvedPath)) {
+        throw new Error(`Function directory is invalid or missing required files: ${resolvedPath}`);
     }
     if (functionConfig.predeployCommands?.length) {
         MessageFormatter.processing("Executing predeploy commands...", { prefix: "Deployment" });

package/dist/functions/methods.js

@@ -6,6 +6,7 @@ import {} from "appwrite-utils";
 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
  * - Filters out empty/invalid strings
@@ -41,7 +42,7 @@ export const downloadLatestFunctionDeployment = async (client, functionId, baseP
     const latestDeployment = functionDeployments.deployments[0];
     const deploymentData = await functions.getDeploymentDownload(functionId, latestDeployment.$id);
     // Create function directory using provided basePath
-    const functionDir = join(basePath, functionInfo.name.toLowerCase().replace(/\s+/g, "-"));
+    const functionDir = join(basePath, normalizeFunctionName(functionInfo.name));
     await fs.promises.mkdir(functionDir, { recursive: true });
     // Create temporary file for tar extraction
     const tarPath = join(functionDir, "temp.tar.gz");
@@ -119,7 +120,8 @@ export const updateFunction = async (client, functionConfig) => {
     return functionResponse;
 };
 export const createFunctionTemplate = async (templateType, functionName, basePath = "./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/dist/functions/pathResolution.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Expands tilde (~) in paths to the user's home directory
+ * @param pathStr - Path string that may contain ~
+ * @returns Expanded path with home directory
+ */
+export declare function expandTildePath(pathStr: string): string;
+/**
+ * Normalizes function name to standard format (lowercase, dashes instead of spaces)
+ * @param name - Function name to normalize
+ * @returns Normalized function name
+ */
+export declare function normalizeFunctionName(name: string): string;
+/**
+ * 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 declare function validateFunctionDirectory(dirPath: string): boolean;
+/**
+ * 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 declare function findFunctionInStandardLocations(configDirPath: string, normalizedName: string): string | 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 declare function resolveFunctionDirectory(functionName: string, configDirPath: string, dirPath?: string, explicitPath?: string): string;

package/dist/functions/pathResolution.js

@@ -0,0 +1,185 @@
+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) {
+    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) {
+    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) {
+    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, normalizedName) {
+    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, configDirPath, dirPath, explicitPath) {
+    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/dist/functions/templates/count-docs-in-collection/README.md

@@ -0,0 +1,54 @@
+# Count Documents in Collection Function
+
+A utility function that accurately counts documents in an Appwrite collection, even when there are more than 5,000 documents.
+
+## Features
+- Handles collections with any number of documents
+- Supports filtering using Appwrite queries
+- Uses efficient binary search algorithm for large collections
+- Provides detailed logging during the counting process
+
+## Structure
+- `src/main.ts`: Main function implementation with counting logic
+- `src/request.ts`: Request validation schema using Zod
+
+## Usage
+Send a POST request with:
+```json
+{
+  "databaseId": "your-database-id",
+  "collectionId": "your-collection-id",
+  "queries": [Query.orderDesc("$createdAt"), Query.contains("name", "John")] // Or put the string array from after this, they are the same
+}
+```
+
+## Response
+```json
+{
+  "success": true,
+  "count": 12345
+}
+```
+
+## Development
+1. Install dependencies: `npm|yarn|bun install`
+2. Build: `npm|yarn|bun run build`
+3. Deploy: Function will be built automatically during deployment
+
+## Deployment
+Make sure it's inside `appwriteConfig.ts` functions array, and if you want to build it FIRST, before Appwrite (using your system), you can
+add the `predeployCommands` to the function in `appwriteConfig.ts`.
+
+## Example Config
+```typescript
+{
+  $id: 'count-docs',
+  name: 'Count Documents',
+  runtime: 'node-18.0',
+  path: 'functions/count-docs',
+  entrypoint: './main.js',
+  execute: ['any'],
+  predeployCommands: ['npm install', 'npm run build'],
+  deployDir: './dist'
+}
+```

package/dist/functions/templates/count-docs-in-collection/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "{{functionName}}",
+  "version": "1.0.0",
+  "description": "Appwrite function to count documents in a collection",
+  "main": "src/main.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/main.js",
+    "dev": "tsx src/main.ts"
+  },
+  "dependencies": {
+    "node-appwrite": "^13.0.0",
+    "appwrite-utils": "latest",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}