appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/adapters/index.d.ts

@@ -1,11 +1,10 @@
 /**
- * Adapters Module - Unified Database API for Appwrite
+ * Adapters Module - Re-exported from appwrite-utils-helpers
  *
- * This module exports all adapter classes and utilities for working with
- * both legacy Appwrite (collections/documents) and TablesDB (tables/rows) APIs.
+ * This module re-exports all adapter classes and utilities from the
+ * appwrite-utils-helpers package for backward compatibility.
+ *
+ * The adapters have been moved to the helpers package to make them
+ * available to other packages and reduce code duplication.
  */
-export { AdapterFactory, type AdapterFactoryConfig, type AdapterFactoryResult } from './AdapterFactory.js';
-export { type DatabaseAdapter, type CreateRowParams, type UpdateRowParams, type ListRowsParams, type DeleteRowParams, type CreateTableParams, type UpdateTableParams, type ListTablesParams, type DeleteTableParams, type GetTableParams, type BulkCreateRowsParams, type BulkUpsertRowsParams, type BulkDeleteRowsParams, type CreateIndexParams, type ListIndexesParams, type DeleteIndexParams, type CreateAttributeParams, type UpdateAttributeParams, type DeleteAttributeParams, type ApiResponse, type AdapterMetadata, BaseAdapter } from './DatabaseAdapter.js';
-export { TablesDBAdapter } from './TablesDBAdapter.js';
-export { LegacyAdapter } from './LegacyAdapter.js';
-export { createDatabaseAdapter, getApiCapabilities } from './AdapterFactory.js';
+export * from 'appwrite-utils-helpers';

package/dist/adapters/index.js

@@ -1,12 +1,10 @@
 /**
- * Adapters Module - Unified Database API for Appwrite
+ * Adapters Module - Re-exported from appwrite-utils-helpers
  *
- * This module exports all adapter classes and utilities for working with
- * both legacy Appwrite (collections/documents) and TablesDB (tables/rows) APIs.
+ * This module re-exports all adapter classes and utilities from the
+ * appwrite-utils-helpers package for backward compatibility.
+ *
+ * The adapters have been moved to the helpers package to make them
+ * available to other packages and reduce code duplication.
  */
-export { AdapterFactory } from './AdapterFactory.js';
-export { BaseAdapter } from './DatabaseAdapter.js';
-export { TablesDBAdapter } from './TablesDBAdapter.js';
-export { LegacyAdapter } from './LegacyAdapter.js';
-// Convenience exports
-export { createDatabaseAdapter, getApiCapabilities } from './AdapterFactory.js';
+export * from 'appwrite-utils-helpers';

package/dist/backups/operations/bucketBackup.js

@@ -2,8 +2,8 @@ import JSZip from "jszip";
 import { ID, Query } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import pLimit from "p-limit";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import { logger } from "../../shared/logging.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
+import { logger } from 'appwrite-utils-helpers';
 import { ulid } from "ulidx";
 /**
  * Downloads all files from a bucket in parallel and creates a ZIP backup

package/dist/backups/operations/collectionBackup.d.ts

@@ -1,5 +1,5 @@
 import type { Storage, Databases } from "node-appwrite";
-import type { DatabaseAdapter } from "../../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from 'appwrite-utils-helpers';
 import type { AppwriteConfig } from "appwrite-utils";
 export interface CollectionBackupOptions {
     trackingDatabaseId: string;

package/dist/backups/operations/collectionBackup.js

@@ -1,11 +1,11 @@
 import { ID, Query } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { ulid } from "ulidx";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import { logger } from "../../shared/logging.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
+import { logger } from 'appwrite-utils-helpers';
 import { tryAwaitWithRetry } from "appwrite-utils";
 import { splitIntoBatches } from "../../shared/migrationHelpers.js";
-import { retryFailedPromises } from "../../utils/retryFailedPromises.js";
+import { retryFailedPromises } from "appwrite-utils-helpers";
 import { ProgressManager } from "../../shared/progressManager.js";
 import { createBackupZip } from "../../storage/backupCompression.js";
 import { recordCentralizedBackup, createCentralizedBackupTrackingTable } from "../tracking/centralizedTracking.js";

package/dist/backups/operations/comprehensiveBackup.d.ts

@@ -1,5 +1,5 @@
 import type { Storage, Databases } from "node-appwrite";
-import type { DatabaseAdapter } from "../../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from 'appwrite-utils-helpers';
 import type { DatabaseBackupReference, BucketBackupReference } from "../schemas/comprehensiveManifest.js";
 import type { AppwriteConfig } from "appwrite-utils";
 export interface ComprehensiveBackupOptions {

package/dist/backups/operations/comprehensiveBackup.js

@@ -1,8 +1,8 @@
 import { ID } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { ulid } from "ulidx";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import { logger } from "../../shared/logging.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
+import { logger } from 'appwrite-utils-helpers';
 import { backupDatabase } from "../../storage/methods.js";
 import { backupBucket } from "./bucketBackup.js";
 import { recordCentralizedBackup, createCentralizedBackupTrackingTable } from "../tracking/centralizedTracking.js";

package/dist/backups/tracking/centralizedTracking.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAdapter } from "../../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from 'appwrite-utils-helpers';
 import { type BackupMetadata, type BackupType } from "../../shared/backupMetadataSchema.js";
 /**
  * Creates the centralized backup tracking table with enhanced schema

package/dist/backups/tracking/centralizedTracking.js

@@ -1,5 +1,5 @@
-import { logger } from "../../shared/logging.js";
-import { tryAwaitWithRetry } from "../../utils/helperFunctions.js";
+import { logger } from 'appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "appwrite-utils-helpers";
 import { Query, ID } from "node-appwrite";
 import { BACKUP_TABLE_ID, BACKUP_TABLE_NAME, BackupMetadataSchema } from "../../shared/backupMetadataSchema.js";
 /**

package/dist/cli/commands/configCommands.js

@@ -1,11 +1,12 @@
 import inquirer from "inquirer";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import fs from "fs";
+import path from "path";
+import { MessageFormatter } from 'appwrite-utils-helpers';
 import { migrateConfig } from "../../utils/configMigration.js";
-import { validateCollectionsTablesConfig, reportValidationResults, } from "../../config/configValidation.js";
-import { createMigrationPlan, executeMigrationPlan, saveMigrationResult, } from "../../config/configMigration.js";
+import { validateCollectionsTablesConfig, reportValidationResults, ConfigManager, findAppwriteConfig, findYamlConfig, YamlLoader, resolveCollectionsDir, resolveTablesDir } from "appwrite-utils-helpers";
+import { createMigrationPlan, executeMigrationPlan, saveMigrationResult, } from 'appwrite-utils-helpers';
 import { createEmptyCollection } from "../../utils/setupFiles.js";
 import chalk from "chalk";
-import { ConfigManager } from "../../config/ConfigManager.js";
 import { UtilsController } from "../../utilsController.js";
 export const configCommands = {
     async migrateTypeScriptConfig(cli) {
@@ -37,7 +38,7 @@ export const configCommands = {
                 MessageFormatter.error("No configuration found to validate", undefined, { prefix: "Validation" });
                 return;
             }
-            const { validateCollectionsTablesConfig, reportValidationResults } = await import("../../config/configValidation.js");
+            const { validateCollectionsTablesConfig, reportValidationResults } = await import("appwrite-utils-helpers");
             const validation = validateCollectionsTablesConfig(config);
             reportValidationResults(validation, { verbose: true });
             if (validation.isValid) {
@@ -55,6 +56,8 @@ export const configCommands = {
         try {
             MessageFormatter.info("Starting collections to tables migration...", { prefix: "Migration" });
             await cli.initControllerIfNeeded();
+            const currentDir = cli.currentDir;
+            const yamlConfigPath = findYamlConfig(currentDir);
             // Ensure config is properly loaded with YAML collections
             if (!cli.controller?.config) {
                 MessageFormatter.error("No configuration found", undefined, { prefix: "Migration" });
@@ -65,7 +68,6 @@ export const configCommands = {
                 MessageFormatter.error("No collections found in configuration. Please check your YAML files or appwriteConfig.ts", undefined, { prefix: "Migration" });
                 return;
             }
-            const { createMigrationPlan, executeMigrationPlan, saveMigrationResult } = await import("../../config/configMigration.js");
             // Get user's migration strategy preference
             const { strategy } = await inquirer.prompt([
                 {
@@ -79,6 +81,46 @@ export const configCommands = {
                     ]
                 }
             ]);
+            if (yamlConfigPath) {
+                const appwriteDir = path.dirname(yamlConfigPath);
+                const collectionsDir = resolveCollectionsDir(appwriteDir);
+                const tablesDir = resolveTablesDir(appwriteDir);
+                if (!fs.existsSync(collectionsDir)) {
+                    MessageFormatter.error(`Collections directory not found: ${collectionsDir}`, undefined, { prefix: "Migration" });
+                    return;
+                }
+                const collectionFiles = fs
+                    .readdirSync(collectionsDir)
+                    .filter(file => file.endsWith(".yaml") || file.endsWith(".yml"));
+                if (collectionFiles.length === 0) {
+                    MessageFormatter.error("No YAML collection files found to migrate.", undefined, { prefix: "Migration" });
+                    return;
+                }
+                const { confirmed } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirmed",
+                        message: `Proceed with migration? This will process ${collectionFiles.length} file(s).`,
+                        default: false
+                    }
+                ]);
+                if (!confirmed) {
+                    MessageFormatter.info("Migration cancelled by user", { prefix: "Migration" });
+                    return;
+                }
+                const yamlLoader = new YamlLoader(appwriteDir);
+                const result = await yamlLoader.migrateTerminology(path.relative(appwriteDir, collectionsDir), path.relative(appwriteDir, tablesDir), true);
+                if (result.errors.length > 0) {
+                    MessageFormatter.warning(`Migration completed with ${result.errors.length} error(s).`, { prefix: "Migration" });
+                }
+                if (strategy === "move") {
+                    const backupDir = `${collectionsDir}.backup.${Date.now()}`;
+                    fs.renameSync(collectionsDir, backupDir);
+                    MessageFormatter.info(`Collections moved to ${path.basename(backupDir)}`, { prefix: "Migration" });
+                }
+                MessageFormatter.success(`Collections migrated to tables (${result.migrated} converted, ${result.skipped} skipped).`, { prefix: "Migration" });
+                return;
+            }
             // Map user-friendly strategy names to internal MigrationStrategy types
             const migrationStrategy = strategy === "move" ? "full_migration" :
                 strategy === "copy" || strategy === "dual" ? "dual_format" : "full_migration";
@@ -93,7 +135,9 @@ export const configCommands = {
             ]);
             if (confirmed) {
                 const result = executeMigrationPlan(cli.controller.config, plan);
-                await saveMigrationResult(result, cli.currentDir);
+                const configDir = findAppwriteConfig(currentDir) || currentDir;
+                const outputPath = path.join(configDir, "appwriteConfig.ts");
+                await saveMigrationResult(result, outputPath, { originalConfigPath: outputPath });
                 MessageFormatter.success("Collections to tables migration completed!", { prefix: "Migration" });
             }
             else {

package/dist/cli/commands/databaseCommands.js

@@ -2,125 +2,177 @@ import inquirer from "inquirer";
 import chalk from "chalk";
 import { join } from "node:path";
 import { Query } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
 import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
 import { SelectionDialogs } from "../../shared/selectionDialogs.js";
-import { logger } from "../../shared/logging.js";
+import { logger } from 'appwrite-utils-helpers';
 import { fetchAllDatabases } from "../../databases/methods.js";
 import { listBuckets } from "../../storage/methods.js";
 import { getFunction, downloadLatestFunctionDeployment } from "../../functions/methods.js";
 import { wipeTableRows } from "../../collections/wipeOperations.js";
 export const databaseCommands = {
     async syncDb(cli) {
-        MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Database" });
+        MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Push" });
         try {
             // Initialize controller
             await cli.controller.init();
-            // Get available and configured databases
-            const availableDatabases = await fetchAllDatabases(cli.controller.database);
-            const configuredDatabases = cli.controller.config?.databases || [];
-            // Get local collections for selection
-            const localCollections = cli.getLocalCollections();
-            // Push operations always use local configuration as source of truth
-            // Select databases
-            const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, { showSelectAll: false, allowNewOnly: false, defaultSelected: [] });
-            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();
-            const availableTablesMap = new Map();
-            for (const databaseId of selectedDatabaseIds) {
-                const database = availableDatabases.find(db => db.$id === databaseId);
-                // Use the existing selectCollectionsAndTables method
-                const selectedCollections = await cli.selectCollectionsAndTables(database, cli.controller.database, chalk.blue(`Select collections/tables to push to "${database.name}":`), true, // multiSelect
-                true, // prefer local
-                true // shouldFilterByDatabase
-                );
-                // Map selected collections to table IDs
-                const selectedTableIds = selectedCollections.map((c) => 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;
-                }
-            }
-            // Ask if user wants to select buckets
-            const { selectBuckets } = await inquirer.prompt([
+            // Ask what to push first
+            const { pushTargets } = await inquirer.prompt([
                 {
-                    type: "confirm",
-                    name: "selectBuckets",
-                    message: "Do you want to select storage buckets to sync as well?",
-                    default: false,
+                    type: "checkbox",
+                    name: "pushTargets",
+                    message: chalk.blue("What would you like to push to Appwrite?"),
+                    choices: [
+                        { name: "Databases & Tables", value: "databases" },
+                        { name: "Storage Buckets", value: "buckets" },
+                        { name: "Functions", value: "functions" },
+                    ],
+                    validate: (input) => {
+                        if (input.length === 0) {
+                            return "Please select at least one item to push.";
+                        }
+                        return true;
+                    },
                 },
             ]);
+            const pushDatabases = pushTargets.includes("databases");
+            const pushBuckets = pushTargets.includes("buckets");
+            const pushFunctions = pushTargets.includes("functions");
+            let databaseSelections = [];
             let bucketSelections = [];
-            if (selectBuckets) {
-                // Get available and configured buckets
+            let mergedDatabases = [];
+            // --- Databases & Tables sub-flow ---
+            if (pushDatabases) {
+                const serverDatabases = await fetchAllDatabases(cli.controller.database);
+                const configuredDatabases = cli.controller.config?.databases || [];
+                const serverDbIds = new Set(serverDatabases.map(db => db.$id));
+                mergedDatabases = [...serverDatabases];
+                for (const configDb of configuredDatabases) {
+                    const dbId = configDb.$id;
+                    if (dbId && !serverDbIds.has(dbId)) {
+                        mergedDatabases.push({
+                            $id: dbId,
+                            name: configDb.name || dbId,
+                            $createdAt: new Date().toISOString(),
+                            $updatedAt: new Date().toISOString(),
+                            enabled: true,
+                            _isLocalOnly: true,
+                        });
+                        MessageFormatter.info(`Including local database "${configDb.name || dbId}" (not yet on server)`, { prefix: "Database" });
+                    }
+                }
+                const selectedDatabaseIds = await SelectionDialogs.selectDatabases(mergedDatabases, configuredDatabases, { showSelectAll: false, allowNewOnly: false, defaultSelected: [] });
+                if (selectedDatabaseIds.length === 0) {
+                    MessageFormatter.warning("No databases selected.", { prefix: "Database" });
+                }
+                else {
+                    const tableSelectionsMap = new Map();
+                    const availableTablesMap = new Map();
+                    for (const databaseId of selectedDatabaseIds) {
+                        const database = mergedDatabases.find(db => db.$id === databaseId);
+                        const selectedCollections = await cli.selectCollectionsAndTables(database, cli.controller.database, chalk.blue(`Select tables to push to "${database.name}":`), true, true, true);
+                        const selectedTableIds = selectedCollections.map((c) => c.$id || c.id);
+                        tableSelectionsMap.set(databaseId, selectedTableIds);
+                        availableTablesMap.set(databaseId, selectedCollections);
+                        if (selectedCollections.length === 0) {
+                            MessageFormatter.warning(`No tables selected for database "${database.name}". Skipping.`, { prefix: "Database" });
+                        }
+                    }
+                    databaseSelections = SelectionDialogs.createDatabaseSelection(selectedDatabaseIds, mergedDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap);
+                }
+            }
+            // --- Storage Buckets sub-flow ---
+            if (pushBuckets) {
                 try {
-                    const availableBucketsResponse = await listBuckets(cli.controller.storage);
-                    const availableBuckets = availableBucketsResponse.buckets || [];
+                    let remoteBuckets = [];
+                    try {
+                        const remoteBucketsResponse = await listBuckets(cli.controller.storage);
+                        remoteBuckets = remoteBucketsResponse.buckets || [];
+                    }
+                    catch (error) {
+                        MessageFormatter.warning("Could not fetch remote buckets, showing local buckets only.", { prefix: "Buckets" });
+                    }
                     const configuredBuckets = cli.controller.config?.buckets || [];
-                    if (availableBuckets.length === 0) {
-                        MessageFormatter.warning("No storage buckets available in remote instance.", { prefix: "Database" });
+                    // Merge local + remote buckets
+                    const remoteBucketIds = new Set(remoteBuckets.map((b) => b.$id));
+                    const localBucketIds = new Set(configuredBuckets.map((b) => b.$id));
+                    const mergedBuckets = [];
+                    for (const rb of remoteBuckets) {
+                        mergedBuckets.push({
+                            ...rb,
+                            _isLocalOnly: false,
+                            _isRemoteOnly: !localBucketIds.has(rb.$id),
+                        });
+                    }
+                    for (const lb of configuredBuckets) {
+                        if (!remoteBucketIds.has(lb.$id)) {
+                            mergedBuckets.push({
+                                $id: lb.$id,
+                                name: lb.name,
+                                enabled: lb.enabled,
+                                maximumFileSize: lb.maximumFileSize,
+                                allowedFileExtensions: lb.allowedFileExtensions || [],
+                                compression: lb.compression || 'none',
+                                encryption: lb.encryption || false,
+                                antivirus: lb.antivirus || false,
+                                fileSecurity: lb.fileSecurity || false,
+                                permissions: lb.permissions || [],
+                                $permissions: [],
+                                _isLocalOnly: true,
+                                _isRemoteOnly: false,
+                            });
+                        }
+                    }
+                    if (mergedBuckets.length === 0) {
+                        MessageFormatter.warning("No storage buckets found (local or remote).", { prefix: "Buckets" });
                     }
                     else {
-                        // Select buckets using SelectionDialogs
-                        const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, { showSelectAll: false, groupByDatabase: true, defaultSelected: [] });
+                        const selectedBucketIds = await SelectionDialogs.selectBucketsForPush(mergedBuckets, configuredBuckets);
                         if (selectedBucketIds.length > 0) {
-                            // Create BucketSelection objects
-                            bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, availableDatabases);
-                            MessageFormatter.info(`Selected ${bucketSelections.length} storage bucket(s)`, { prefix: "Database" });
+                            bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, mergedBuckets, configuredBuckets, mergedDatabases);
+                            MessageFormatter.info(`Selected ${bucketSelections.length} storage bucket(s)`, { prefix: "Buckets" });
                         }
                     }
                 }
                 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) });
+                    MessageFormatter.warning("Failed during bucket selection.", { prefix: "Buckets" });
+                    logger.warn("Bucket selection 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;
+            // --- Confirmation ---
+            if (databaseSelections.length > 0 || bucketSelections.length > 0) {
+                const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
+                const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'push');
+                if (!confirmed) {
+                    MessageFormatter.info("Push operation cancelled by user", { prefix: "Push" });
+                    return;
+                }
+                MessageFormatter.progress("Starting selective push...", { prefix: "Push" });
+                await cli.controller.selectivePush(databaseSelections, bucketSelections);
+                MessageFormatter.success("Configuration pushed successfully!", { prefix: "Push" });
             }
-            // 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([
-                {
-                    type: "confirm",
-                    name: "syncFunctions",
-                    message: "Do you want to push local functions to remote?",
-                    default: false,
-                },
-            ]);
-            if (syncFunctions && cli.controller.config?.functions?.length) {
-                const functions = await cli.selectFunctions(chalk.blue("Select local functions to push:"), true, true // prefer local
-                );
-                for (const func of functions) {
-                    try {
-                        await cli.controller.deployFunction(func.name);
-                        MessageFormatter.success(`Function ${func.name} deployed successfully`, { prefix: "Functions" });
-                    }
-                    catch (error) {
-                        MessageFormatter.error(`Failed to deploy function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
+            // --- Functions sub-flow ---
+            if (pushFunctions) {
+                if (!cli.controller.config?.functions?.length) {
+                    MessageFormatter.warning("No functions defined in local config.", { prefix: "Functions" });
+                }
+                else {
+                    const functions = await cli.selectFunctions(chalk.blue("Select local functions to push:"), true, true);
+                    for (const func of functions) {
+                        try {
+                            await cli.controller.deployFunction(func.name);
+                            MessageFormatter.success(`Function ${func.name} deployed successfully`, { prefix: "Functions" });
+                        }
+                        catch (error) {
+                            MessageFormatter.error(`Failed to deploy function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
+                        }
                     }
                 }
             }
-            MessageFormatter.success("Local configuration push completed successfully!", { prefix: "Database" });
+            MessageFormatter.success("Push operation completed!", { prefix: "Push" });
         }
         catch (error) {
-            MessageFormatter.error("Failed to push local configuration", error instanceof Error ? error : new Error(String(error)), { prefix: "Database" });
+            MessageFormatter.error("Failed to push local configuration", error instanceof Error ? error : new Error(String(error)), { prefix: "Push" });
             throw error;
         }
     },
@@ -132,7 +184,7 @@ export const databaseCommands = {
             {
                 type: "confirm",
                 name: "syncDatabases",
-                message: "Do you want to synchronize databases, collections, and their buckets?",
+                message: "Do you want to synchronize databases, tables, and their buckets?",
                 default: true,
             },
         ]);
@@ -153,7 +205,7 @@ export const databaseCommands = {
             // Update controller config with bucket selections
             cli.controller.config = configWithBuckets;
             // Now synchronize configurations with the updated config that includes bucket selections
-            MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
+            MessageFormatter.progress("Pulling tables and generating table files...", { prefix: "Tables" });
             await cli.controller.synchronizeConfigurations(remoteDatabases, configWithBuckets);
         }
         // Then sync functions
@@ -209,7 +261,7 @@ export const databaseCommands = {
                             timeout: remoteFunction.timeout || 15,
                             enabled: remoteFunction.enabled !== false,
                             logging: remoteFunction.logging !== false,
-                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
+                            entrypoint: remoteFunction.entrypoint || "src/main.ts",
                             commands: remoteFunction.commands || "npm install",
                             scopes: remoteFunction.scopes || [],
                             installationId: remoteFunction.installationId,
@@ -275,7 +327,7 @@ export const databaseCommands = {
                             timeout: remoteFunction.timeout || 15,
                             enabled: remoteFunction.enabled !== false,
                             logging: remoteFunction.logging !== false,
-                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
+                            entrypoint: remoteFunction.entrypoint || "src/main.ts",
                             commands: remoteFunction.commands || "npm install",
                             scopes: remoteFunction.scopes || [],
                             installationId: remoteFunction.installationId,
@@ -360,7 +412,7 @@ export const databaseCommands = {
                 choices: [
                     { name: "Comprehensive (ALL databases + ALL buckets)", value: "comprehensive" },
                     { name: "Selective databases (choose specific databases)", value: "selective-databases" },
-                    { name: "Selective collections (choose specific collections)", value: "selective-collections" }
+                    { name: "Selective tables (choose specific tables)", value: "selective-tables" }
                 ]
             }
         ]);
@@ -400,17 +452,17 @@ export const databaseCommands = {
                 buckets: selectedBuckets
             };
         }
-        if (scopeType === "selective-collections") {
+        if (scopeType === "selective-tables") {
             const databases = await fetchAllDatabases(cli.controller.database);
-            const selectedDatabase = await cli.selectDatabases(databases, "Select database containing collections:", false // single selection
+            const selectedDatabase = await cli.selectDatabases(databases, "Select database containing tables:", false // single selection
             );
             if (!selectedDatabase || selectedDatabase.length === 0) {
                 throw new Error("No database selected");
             }
             const db = selectedDatabase[0];
-            const collections = await cli.selectCollectionsAndTables(db, cli.controller.database, "Select collections to backup:", true, true, true);
+            const collections = await cli.selectCollectionsAndTables(db, cli.controller.database, "Select tables to backup:", true, true, true);
             return {
-                type: "selective-collections",
+                type: "selective-tables",
                 databaseId: db.$id,
                 databaseName: db.name,
                 collections: collections
@@ -431,9 +483,9 @@ export const databaseCommands = {
                 summary += `  • ${scope.buckets.length} selected buckets\n`;
             }
         }
-        else if (scope.type === "selective-collections") {
+        else if (scope.type === "selective-tables") {
             summary += `  • Database: ${scope.databaseName}\n`;
-            summary += `  • ${scope.collections.length} selected collections\n`;
+            summary += `  • ${scope.collections.length} selected tables\n`;
         }
         console.log(summary);
         const { confirmed } = await inquirer.prompt([
@@ -472,7 +524,7 @@ export const databaseCommands = {
                 await backupBucket(cli.controller.storage, bucketId, "appwrite-backups", { parallelDownloads: 10 });
             }
         }
-        else if (scope.type === "selective-collections") {
+        else if (scope.type === "selective-tables") {
             const { backupCollections } = await import("../../backups/operations/collectionBackup.js");
             await backupCollections(cli.controller.config, cli.controller.database, cli.controller.storage, cli.controller.adapter, {
                 trackingDatabaseId,
@@ -535,23 +587,23 @@ export const databaseCommands = {
             throw new Error("Database is not initialized, is the config file correct & created?");
         }
         const databases = await fetchAllDatabases(cli.controller.database);
-        const selectedDatabases = await cli.selectDatabases(databases, "Select the database(s) containing the collections to wipe:", true);
+        const selectedDatabases = await cli.selectDatabases(databases, "Select the database(s) containing the tables to wipe:", true);
         for (const database of selectedDatabases) {
-            const collections = await cli.selectCollectionsAndTables(database, cli.controller.database, `Select collections/tables to wipe from ${database.name}:`, true, undefined, true);
+            const collections = await cli.selectCollectionsAndTables(database, cli.controller.database, `Select tables to wipe from ${database.name}:`, true, undefined, true);
             const collectionNames = collections.map((c) => c.name);
             const confirmed = await ConfirmationDialogs.confirmCollectionWipe(database.name, collectionNames);
             if (confirmed) {
-                MessageFormatter.info(`Wiping selected collections from ${database.name}...`, { prefix: "Wipe" });
+                MessageFormatter.info(`Wiping selected tables from ${database.name}...`, { prefix: "Wipe" });
                 for (const collection of collections) {
                     await cli.controller.wipeCollection(database, collection);
-                    MessageFormatter.success(`Collection ${collection.name} wiped successfully`, { prefix: "Wipe" });
+                    MessageFormatter.success(`Table ${collection.name} wiped successfully`, { prefix: "Wipe" });
                 }
             }
             else {
                 MessageFormatter.info(`Wipe operation cancelled for ${database.name}`, { prefix: "Wipe" });
             }
         }
-        MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
+        MessageFormatter.success("Wipe tables operation completed", { prefix: "Wipe" });
     },
     async wipeTablesData(cli) {
         const controller = cli.controller;

package/dist/cli/commands/functionCommands.js

@@ -5,11 +5,11 @@ import os from "node:os";
 import { ulid } from "ulidx";
 import chalk from "chalk";
 import { Query } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
 import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, listFunctions, listSpecifications, } from "../../functions/methods.js";
 import { deployLocalFunction } from "../../functions/deployments.js";
 import { discoverFnConfigs, mergeDiscoveredFunctions } from "../../functions/fnConfigDiscovery.js";
-import { addFunctionToYamlConfig, findYamlConfig } from "../../config/yamlConfig.js";
+import { addFunctionToYamlConfig, findYamlConfig } from "appwrite-utils-helpers";
 import { RuntimeSchema } from "appwrite-utils";
 export const functionCommands = {
     async createFunction(cli) {
@@ -260,7 +260,7 @@ export const functionCommands = {
                 await deployLocalFunction(cli.controller.appwriteServer, effectiveConfig.name, {
                     ...effectiveConfig,
                     dirPath: functionPath,
-                }, functionPath);
+                }, functionPath, yamlBaseDir);
                 MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });
             }
             catch (error) {