@njdamstra/appwrite-utils-cli 1.10.1 → 1.11.1

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

@@ -0,0 +1,6 @@
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare const migrateCommands: {
+    migrateStrings(cli: InteractiveCLI): Promise<void>;
+    analyzePhase(cli: InteractiveCLI): Promise<void>;
+    executePhase(cli: InteractiveCLI): Promise<void>;
+};

package/dist/cli/commands/migrateCommands.js

@@ -0,0 +1,109 @@
+import inquirer from "inquirer";
+import path from "node:path";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { analyzeStringAttributes, executeMigrationPlan, } from "../../migrations/migrateStrings.js";
+export const migrateCommands = {
+    async migrateStrings(cli) {
+        const { phase } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "phase",
+                message: "String attribute migration:",
+                choices: [
+                    {
+                        name: "Analyze — scan Appwrite server, generate migration plan (YAML)",
+                        value: "analyze",
+                    },
+                    {
+                        name: "Execute — run a migration plan against Appwrite server",
+                        value: "execute",
+                    },
+                    { name: "Back", value: "back" },
+                ],
+            },
+        ]);
+        if (phase === "back")
+            return;
+        if (phase === "analyze") {
+            await migrateCommands.analyzePhase(cli);
+        }
+        else {
+            await migrateCommands.executePhase(cli);
+        }
+    },
+    async analyzePhase(cli) {
+        const controller = cli.controller;
+        if (!controller?.adapter) {
+            MessageFormatter.error("No database adapter available. Ensure a server connection is established.", undefined, { prefix: "Analyze" });
+            return;
+        }
+        // Prompt for output path
+        const { outputPath } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "outputPath",
+                message: "Output path for migration plan:",
+                default: path.join(process.cwd(), "migrate-strings-plan.yaml"),
+            },
+        ]);
+        const options = { outputPath };
+        try {
+            await analyzeStringAttributes(controller.adapter, controller.config, options);
+            MessageFormatter.success("Analysis complete. Review the YAML plan, edit targetType/action as needed, then run Execute.", { prefix: "Analyze" });
+        }
+        catch (err) {
+            MessageFormatter.error(`Analysis failed: ${err.message}`, undefined, { prefix: "Analyze" });
+        }
+    },
+    async executePhase(cli) {
+        const controller = cli.controller;
+        if (!controller?.adapter) {
+            MessageFormatter.error("No database adapter available. Ensure a server connection is established.", undefined, { prefix: "Execute" });
+            return;
+        }
+        // Prompt for plan path
+        const { planPath } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "planPath",
+                message: "Path to migration plan YAML:",
+                default: path.join(process.cwd(), "migrate-strings-plan.yaml"),
+            },
+        ]);
+        const { keepBackups } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "keepBackups",
+                message: "Keep backup attributes after migration? (safer, uses more attribute slots)",
+                default: true,
+            },
+        ]);
+        const { dryRun } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "dryRun",
+                message: "Dry run? (no actual changes)",
+                default: false,
+            },
+        ]);
+        const options = {
+            planPath,
+            keepBackups,
+            dryRun,
+        };
+        try {
+            const results = await executeMigrationPlan(controller.adapter, options);
+            if (results.failed > 0) {
+                MessageFormatter.warning(`Migration completed with ${results.failed} failure(s). Check checkpoint file to resume.`, { prefix: "Execute" });
+            }
+            else {
+                MessageFormatter.success("Migration completed successfully.", {
+                    prefix: "Execute",
+                });
+            }
+        }
+        catch (err) {
+            MessageFormatter.error(`Execution failed: ${err.message}`, undefined, { prefix: "Execute" });
+        }
+    },
+};

package/dist/interactiveCLI.js

@@ -22,6 +22,7 @@ import { storageCommands } from "./cli/commands/storageCommands.js";
 import { transferCommands } from "./cli/commands/transferCommands.js";
 import { schemaCommands } from "./cli/commands/schemaCommands.js";
 import { importFileCommands } from "./cli/commands/importFileCommands.js";
+import { migrateCommands } from "./cli/commands/migrateCommands.js";
 var CHOICES;
 (function (CHOICES) {
     CHOICES["MIGRATE_CONFIG"] = "\uD83D\uDD04 Migrate TypeScript config to YAML (.appwrite structure)";
@@ -47,6 +48,7 @@ var CHOICES;
     CHOICES["RELOAD_CONFIG"] = "\uD83D\uDD04 Reload configuration files";
     CHOICES["UPDATE_FUNCTION_SPEC"] = "\u2699\uFE0F Update function specifications";
     CHOICES["MANAGE_BUCKETS"] = "\uD83E\uDEA3 Manage storage buckets";
+    CHOICES["MIGRATE_STRINGS"] = "\uD83D\uDD04 Migrate string attributes to varchar/text types";
     CHOICES["EXIT"] = "\uD83D\uDC4B Exit";
 })(CHOICES || (CHOICES = {}));
 export class InteractiveCLI {
@@ -165,6 +167,10 @@ export class InteractiveCLI {
                 case CHOICES.MANAGE_BUCKETS:
                     await this.manageBuckets();
                     break;
+                case CHOICES.MIGRATE_STRINGS:
+                    await this.initControllerIfNeeded();
+                    await migrateCommands.migrateStrings(this);
+                    break;
                 case CHOICES.EXIT:
                     MessageFormatter.success("Goodbye!");
                     process.exit(0);

package/dist/main.js

@@ -454,6 +454,32 @@ const argv = yargs(hideBin(process.argv))
     alias: ["target-table"],
     type: "string",
     description: "Target table ID for --importFile (prompted if omitted)",
+})
+    .option("migrateStringsAnalyze", {
+    alias: ["migrate-strings-analyze"],
+    type: "boolean",
+    description: "Analyze local configs and generate a string-to-varchar/text migration plan (YAML)",
+})
+    .option("migrateStringsExecute", {
+    alias: ["migrate-strings-execute"],
+    type: "string",
+    description: "Execute a string migration plan from the given YAML path",
+})
+    .option("migrateStringsOutput", {
+    alias: ["migrate-strings-output"],
+    type: "string",
+    description: "Output path for the migration plan (default: ./migrate-strings-plan.yaml)",
+})
+    .option("migrateStringsKeepBackups", {
+    alias: ["migrate-strings-keep-backups"],
+    type: "boolean",
+    default: true,
+    description: "Keep backup attributes after migration (default: true)",
+})
+    .option("migrateStringsDryRun", {
+    alias: ["migrate-strings-dry-run"],
+    type: "boolean",
+    description: "Dry run — show what would happen without making changes",
 })
     .parse();
 async function main() {
@@ -618,6 +644,34 @@ async function main() {
             }
             return;
         }
+        // String attribute migration (analyze or execute)
+        if (argv.migrateStringsAnalyze || argv.migrateStringsExecute) {
+            const { analyzeStringAttributes, executeMigrationPlan } = await import("./migrations/migrateStrings.js");
+            if (argv.migrateStringsAnalyze) {
+                if (!controller.adapter) {
+                    MessageFormatter.error("No database adapter available. Ensure config has valid credentials.", undefined, { prefix: "Migration" });
+                    return;
+                }
+                await analyzeStringAttributes(controller.adapter, controller.config, {
+                    outputPath: argv.migrateStringsOutput,
+                });
+            }
+            else if (argv.migrateStringsExecute) {
+                if (!controller.adapter) {
+                    MessageFormatter.error("No database adapter available. Ensure config has valid credentials.", undefined, { prefix: "Migration" });
+                    return;
+                }
+                const results = await executeMigrationPlan(controller.adapter, {
+                    planPath: argv.migrateStringsExecute,
+                    keepBackups: argv.migrateStringsKeepBackups ?? true,
+                    dryRun: argv.migrateStringsDryRun ?? false,
+                });
+                if (results.failed > 0) {
+                    process.exit(1);
+                }
+            }
+            return;
+        }
         // List backups if requested
         if (parsedArgv.listBackups) {
             const { AdapterFactory } = await import("@njdamstra/appwrite-utils-helpers");

package/dist/migrations/migrateStrings.d.ts

@@ -0,0 +1,9 @@
+import { type DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import type { AppwriteConfig } from "@njdamstra/appwrite-utils";
+import { type MigrationPlan, type AnalyzeOptions, type ExecuteOptions } from "./migrateStringsTypes.js";
+export declare function analyzeStringAttributes(adapter: DatabaseAdapter, config: AppwriteConfig, options?: AnalyzeOptions): Promise<MigrationPlan>;
+export declare function executeMigrationPlan(adapter: DatabaseAdapter, options: ExecuteOptions): Promise<{
+    succeeded: number;
+    failed: number;
+    skipped: number;
+}>;