@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

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 '@njdamstra/appwrite-utils-helpers';
+import { logger } from '@njdamstra/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 '@njdamstra/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 '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/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 '@njdamstra/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 "@njdamstra/appwrite-utils-helpers";
+import { createMigrationPlan, executeMigrationPlan, saveMigrationResult, } from '@njdamstra/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("@njdamstra/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.d.ts

@@ -10,4 +10,5 @@ export declare const databaseCommands: {
     executeUnifiedBackup(cli: InteractiveCLI, trackingDatabaseId: string, scope: any): Promise<void>;
     wipeDatabase(cli: InteractiveCLI): Promise<void>;
     wipeCollections(cli: InteractiveCLI): Promise<void>;
+    wipeTablesData(cli: InteractiveCLI): Promise<void>;
 };

package/dist/cli/commands/databaseCommands.js

@@ -1,27 +1,49 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { join } from "node:path";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { Query } from "node-appwrite";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
 import { SelectionDialogs } from "../../shared/selectionDialogs.js";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/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" });
         try {
             // Initialize controller
             await cli.controller.init();
-            // Get available and configured databases
-            const availableDatabases = await fetchAllDatabases(cli.controller.database);
+            // Get available databases from server and configured databases from local config
+            const serverDatabases = await fetchAllDatabases(cli.controller.database);
             const configuredDatabases = cli.controller.config?.databases || [];
+            // For PUSH operations: Merge local configured databases with server databases
+            // This allows pushing databases that don't exist on the server yet
+            const serverDbIds = new Set(serverDatabases.map(db => db.$id));
+            const mergedDatabases = [...serverDatabases];
+            // Add locally configured databases that don't exist on server yet
+            for (const configDb of configuredDatabases) {
+                const dbId = configDb.$id;
+                if (dbId && !serverDbIds.has(dbId)) {
+                    // Create a pseudo-database object for selection
+                    mergedDatabases.push({
+                        $id: dbId,
+                        name: configDb.name || dbId,
+                        $createdAt: new Date().toISOString(),
+                        $updatedAt: new Date().toISOString(),
+                        enabled: true,
+                        _isLocalOnly: true, // Mark as not yet on server
+                    });
+                    MessageFormatter.info(`Including local database "${configDb.name || dbId}" (not yet on server)`, { prefix: "Database" });
+                }
+            }
             // 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: [] });
+            // Select databases (now includes locally configured databases that don't exist on server)
+            const selectedDatabaseIds = await SelectionDialogs.selectDatabases(mergedDatabases, configuredDatabases, { showSelectAll: false, allowNewOnly: false, defaultSelected: [] });
             if (selectedDatabaseIds.length === 0) {
                 MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
                 return;
@@ -30,7 +52,7 @@ export const databaseCommands = {
             const tableSelectionsMap = new Map();
             const availableTablesMap = new Map();
             for (const databaseId of selectedDatabaseIds) {
-                const database = availableDatabases.find(db => db.$id === databaseId);
+                const database = mergedDatabases.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
@@ -70,7 +92,7 @@ export const databaseCommands = {
                         const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, { showSelectAll: false, groupByDatabase: true, defaultSelected: [] });
                         if (selectedBucketIds.length > 0) {
                             // Create BucketSelection objects
-                            bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, availableDatabases);
+                            bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, mergedDatabases);
                             MessageFormatter.info(`Selected ${bucketSelections.length} storage bucket(s)`, { prefix: "Database" });
                         }
                     }
@@ -81,7 +103,7 @@ export const databaseCommands = {
                 }
             }
             // Create DatabaseSelection objects
-            const databaseSelections = SelectionDialogs.createDatabaseSelection(selectedDatabaseIds, availableDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap);
+            const databaseSelections = SelectionDialogs.createDatabaseSelection(selectedDatabaseIds, mergedDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap);
             // Show confirmation summary
             const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
             const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'push');
@@ -550,5 +572,93 @@ export const databaseCommands = {
             }
         }
         MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
+    },
+    async wipeTablesData(cli) {
+        const controller = cli.controller;
+        if (!controller?.adapter) {
+            throw new Error("Database adapter is not initialized. TablesDB operations require adapter support.");
+        }
+        try {
+            // Step 1: Select database (single selection for clearer UX)
+            const databases = await fetchAllDatabases(controller.database);
+            if (!databases || databases.length === 0) {
+                MessageFormatter.warning("No databases found", { prefix: "Wipe" });
+                return;
+            }
+            const { selectedDatabase } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedDatabase",
+                    message: "Select database containing tables to wipe:",
+                    choices: databases.map((db) => ({
+                        name: `${db.name} (${db.$id})`,
+                        value: db
+                    }))
+                }
+            ]);
+            const database = selectedDatabase;
+            // Step 2: Get available tables
+            const adapter = controller.adapter;
+            const tablesResponse = await adapter.listTables({
+                databaseId: database.$id,
+                queries: [Query.limit(500)]
+            });
+            const availableTables = tablesResponse.tables || [];
+            if (availableTables.length === 0) {
+                MessageFormatter.warning(`No tables found in database: ${database.name}`, { prefix: "Wipe" });
+                return;
+            }
+            // Step 3: Select tables using existing SelectionDialogs
+            const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(database.$id, database.name, availableTables, [], // No configured tables context needed for wipe
+            {
+                showSelectAll: true,
+                allowNewOnly: false,
+                defaultSelected: []
+            });
+            if (selectedTableIds.length === 0) {
+                MessageFormatter.warning("No tables selected. Operation cancelled.", { prefix: "Wipe" });
+                return;
+            }
+            // Step 4: Show confirmation with table details
+            const selectedTables = availableTables.filter((t) => selectedTableIds.includes(t.$id));
+            const tableNames = selectedTables.map((t) => t.name);
+            console.log(chalk.yellow.bold("\n⚠️  WARNING: Table Row Wipe Operation"));
+            console.log(chalk.yellow("This will delete ALL ROWS from the selected tables."));
+            console.log(chalk.yellow("The table structures will remain intact.\n"));
+            console.log(chalk.cyan("Database:"), chalk.white(database.name));
+            console.log(chalk.cyan("Tables to wipe:"));
+            tableNames.forEach((name) => console.log(chalk.white(`  • ${name}`)));
+            console.log();
+            const { confirmed } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirmed",
+                    message: chalk.red.bold("Are you ABSOLUTELY SURE you want to wipe these table rows?"),
+                    default: false
+                }
+            ]);
+            if (!confirmed) {
+                MessageFormatter.info("Wipe operation cancelled by user", { prefix: "Wipe" });
+                return;
+            }
+            // Step 5: Execute wipe using existing wipeTableRows function
+            MessageFormatter.progress("Starting table row wipe operation...", { prefix: "Wipe" });
+            for (const table of selectedTables) {
+                try {
+                    MessageFormatter.info(`Wiping rows from table: ${table.name}`, { prefix: "Wipe" });
+                    // Use existing wipeTableRows from wipeOperations.ts
+                    await wipeTableRows(adapter, database.$id, table.$id);
+                    MessageFormatter.success(`Successfully wiped rows from table: ${table.name}`, { prefix: "Wipe" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Failed to wipe table ${table.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
+                }
+            }
+            MessageFormatter.success(`Wipe operation completed for ${selectedTables.length} table(s)`, { prefix: "Wipe" });
+        }
+        catch (error) {
+            MessageFormatter.error("Table wipe operation failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
+            throw error;
+        }
     }
 };

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 '@njdamstra/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 "@njdamstra/appwrite-utils-helpers";
 import { RuntimeSchema } from "@njdamstra/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) {

package/dist/cli/commands/importFileCommands.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare function importFileFromPath(adapter: DatabaseAdapter, filePath: string, databaseId: string, tableId: string): Promise<void>;
+export declare function importFilePromptMissing(adapter: DatabaseAdapter, database: any, filePath: string, targetDb?: string, targetTable?: string): Promise<void>;
+export declare const importFileCommands: {
+    importFile(cli: InteractiveCLI): Promise<void>;
+};