@inforge/migrations-tools-cli 1.0.0 → 1.1.1

package/README.md

@@ -4,10 +4,13 @@ Inforge's interactive CLI tool that enables side-effect-free Salesforce data ope
 
 ## Features
 
+- **Feature-grouped menu** - Organized by Automations, Backups, and Logs
+- **Object search/filter** - Instantly find objects by typing instead of scrolling
+- **Individual automation control** - Toggle specific automations with granular preview
 - **Deactivate automation** (validation rules, flows, triggers) for clean data operations
 - **Smart restore** with automatic state detection
 - **Atomic operations** with automatic rollback on failure
-- **Local backups** organized by org/object/type
+- **Local backups** organized by org/object/type with operation type labels
 - **Managed package awareness** - skip managed components gracefully
 - **Full audit logging** for compliance
 - **Beautiful interactive UI** powered by @clack/prompts
@@ -44,27 +47,37 @@ npx @inforge/migrations-tools-cli
 
 ### Deactivate Automation
 
-1. Select "Deactivate automation"
-2. Choose org, object, and automation type
+1. Select "Automations" > "Deactivate all"
+2. Choose org, object (with search/filter), and automation type
 3. Preview what will be affected
 4. Confirm and execute
 5. Backup saved automatically
 
+### Manage Automations Individually
+
+1. Select "Automations" > "Manage individually"
+2. Choose org and object (with search/filter)
+3. Choose automation type
+4. Select specific items to toggle with checkboxes
+5. Preview changes (activations and deactivations)
+6. Confirm and execute
+7. Backup saved automatically as "individual" operation
+
 ### Restore from Backup
 
-1. Select "Restore from backup"
-2. Choose org, object, and automation type
-3. Select backup from list (with metadata)
+1. Select "Automations" > "Restore"
+2. Choose org, object (with search/filter), and automation type
+3. Select backup from list (labels show "Bulk deactivate" or "Individual changes")
 4. Preview smart detection (only restore what's needed)
 5. Confirm and execute
 
 ### Manage Backups
 
-View all backups organized by org/object/type.
+Select "Backups" to view all backups organized by org/object/type.
 
 ### View Logs
 
-See recent operations with status, timestamps, and details.
+Select "Logs" to see recent operations with status, timestamps, and details.
 
 ## Architecture
 

package/dist/index.js

@@ -34,6 +34,49 @@ var Prompts = class {
     }
     return selected;
   }
+  async selectObjectWithSearch(objects) {
+    const filter = await clack.text({
+      message: "Filter objects (leave empty for all):",
+      placeholder: "Type to filter...",
+      defaultValue: ""
+    });
+    if (clack.isCancel(filter)) {
+      this.cancel();
+    }
+    const filterStr = filter.toLowerCase().trim();
+    const filteredObjects = filterStr ? objects.filter((obj) => obj.toLowerCase().includes(filterStr)) : objects;
+    const selected = await clack.select({
+      message: `Select an object (${filteredObjects.length} matches):`,
+      options: filteredObjects.map((obj) => ({ value: obj, label: obj }))
+    });
+    if (clack.isCancel(selected)) {
+      this.cancel();
+    }
+    return selected;
+  }
+  async selectWithCheckboxes(message, items, managedItems) {
+    const options = [
+      ...items.map((item) => ({
+        value: item.fullName,
+        label: `${item.fullName} (${item.active ? "Active" : "Inactive"})`
+      })),
+      ...managedItems.map((item) => ({
+        value: item.fullName,
+        label: `${item.fullName} (Active)`,
+        hint: `Managed by ${item.namespace} - cannot modify`
+      }))
+    ];
+    const selected = await clack.multiselect({
+      message,
+      options,
+      required: false
+    });
+    if (clack.isCancel(selected)) {
+      this.cancel();
+    }
+    const managedFullNames = new Set(managedItems.map((m) => m.fullName));
+    return selected.filter((s) => !managedFullNames.has(s));
+  }
   async selectAutomationType() {
     const selected = await clack.select({
       message: "Select automation type:",
@@ -52,10 +95,9 @@ var Prompts = class {
     const selected = await clack.select({
       message: "What would you like to do?",
       options: [
-        { value: "deactivate", label: "Deactivate automation" },
-        { value: "restore", label: "Restore from backup" },
-        { value: "manage", label: "Manage backups" },
-        { value: "logs", label: "View operation logs" },
+        { value: "automations", label: "Automations" },
+        { value: "backups", label: "Backups" },
+        { value: "logs", label: "Logs" },
         { value: "exit", label: "Exit" }
       ]
     });
@@ -144,7 +186,7 @@ var BackupManager = class {
   constructor(backupDir = ".backups") {
     this.backupDir = backupDir;
   }
-  async save(org, object, type, items, managedItems) {
+  async save(org, object, type, items, managedItems, operationType = "bulk") {
     const timestamp = this.generateTimestamp();
     const backupPath = this.getBackupPath(org.alias, object, type, timestamp);
     const backup = {
@@ -153,6 +195,7 @@ var BackupManager = class {
       org,
       object,
       type,
+      operationType,
       items,
       managedItems,
       restoredAt: null,
@@ -422,12 +465,20 @@ var TriggersHandler = class {
     await this.updateStatus(connection, triggerNames, "Active");
   }
   async updateStatus(connection, triggerNames, status) {
-    const metadata = await connection.metadata.read("ApexTrigger", triggerNames);
-    const updates = metadata.map((trigger) => ({
-      ...trigger,
-      status
+    const query = `
+      SELECT Id, Name
+      FROM ApexTrigger
+      WHERE Name IN (${triggerNames.map((n) => `'${n}'`).join(", ")})
+    `;
+    const result = await connection.tooling.query(query);
+    if (result.records.length === 0) {
+      throw new Error("No triggers found with the specified names");
+    }
+    const updates = result.records.map((trigger) => ({
+      Id: trigger.Id,
+      Status: status
     }));
-    const results = await connection.metadata.update("ApexTrigger", updates);
+    const results = await connection.tooling.update("ApexTrigger", updates);
     if (Array.isArray(results)) {
       const failures = results.filter((r) => !r.success);
       if (failures.length > 0) {
@@ -459,7 +510,7 @@ var DeactivateCommand = class {
     const org = orgs.find((o) => o.alias === selectedOrg);
     const connection = await this.sfClient.getConnection(selectedOrg);
     const objects = await this.sfClient.queryObjects(connection);
-    const selectedObject = await this.prompts.selectObject(objects);
+    const selectedObject = await this.prompts.selectObjectWithSearch(objects);
     const automationType = await this.prompts.selectAutomationType();
     if (automationType === "validation-rules") {
       await this.deactivateValidationRules(org, selectedObject, connection);
@@ -744,7 +795,7 @@ var RestoreCommand = class {
     const org = orgs.find((o) => o.alias === selectedOrg);
     const connection = await this.sfClient.getConnection(selectedOrg);
     const objects = await this.sfClient.queryObjects(connection);
-    const selectedObject = await this.prompts.selectObject(objects);
+    const selectedObject = await this.prompts.selectObjectWithSearch(objects);
     const automationType = await this.prompts.selectAutomationType();
     const backups = await this.backupManager.list(selectedOrg, selectedObject, automationType);
     if (backups.length === 0) {
@@ -756,10 +807,12 @@ var RestoreCommand = class {
         const backup2 = await this.backupManager.load(backupPath);
         const filename = path3.basename(backupPath, ".json");
         const status = backup2.restoredAt ? `restored on ${backup2.restoredAt.split("T")[0]}` : "not restored";
+        const opType = backup2.operationType === "individual" ? "Individual changes" : "Bulk deactivate";
+        const itemCount = `${backup2.items.length} ${backup2.type === "validation-rules" ? "rules" : backup2.type}`;
         return {
           value: backupPath,
-          label: filename,
-          hint: `${backup2.items.length} items, ${status}`
+          label: `${filename} - ${opType}`,
+          hint: `${itemCount}, ${status}`
         };
       })
     );
@@ -1007,10 +1060,243 @@ var RestoreCommand = class {
   }
 };
 
-// src/commands/manage.ts
+// src/commands/individual.ts
+var IndividualCommand = class {
+  sfClient;
+  backupManager;
+  logger;
+  prompts;
+  constructor() {
+    this.sfClient = new SfClient();
+    this.backupManager = new BackupManager();
+    this.logger = new Logger();
+    this.prompts = new Prompts();
+  }
+  async execute() {
+    const orgs = await this.sfClient.listOrgs();
+    if (orgs.length === 0) {
+      this.prompts.error("No authenticated orgs found.");
+      return;
+    }
+    const selectedOrg = await this.prompts.selectOrg(orgs);
+    const org = orgs.find((o) => o.alias === selectedOrg);
+    const connection = await this.sfClient.getConnection(selectedOrg);
+    const objects = await this.sfClient.queryObjects(connection);
+    const selectedObject = await this.prompts.selectObjectWithSearch(objects);
+    const automationType = await this.prompts.selectAutomationType();
+    const spinner2 = this.prompts.spinner();
+    spinner2.start("Fetching automations...");
+    let currentItems;
+    let managedItems;
+    let handler;
+    if (automationType === "validation-rules") {
+      handler = new ValidationRulesHandler();
+    } else if (automationType === "flows") {
+      handler = new FlowsHandler();
+    } else {
+      handler = new TriggersHandler();
+    }
+    const separated = await handler.fetchSeparated(connection, selectedObject);
+    currentItems = separated.custom;
+    managedItems = separated.managed;
+    spinner2.stop("Automations fetched");
+    if (currentItems.length === 0 && managedItems.length === 0) {
+      this.prompts.warning(`No ${automationType} found for ${selectedObject}.`);
+      return;
+    }
+    const selectedFullNames = await this.prompts.selectWithCheckboxes(
+      `${selectedObject} > ${automationType}
+
+Select items to toggle (Space to select, Enter to continue):`,
+      currentItems,
+      managedItems
+    );
+    if (selectedFullNames.length === 0) {
+      this.prompts.warning("No changes selected.");
+      return;
+    }
+    const currentItemsMap = new Map(currentItems.map((item) => [item.fullName, item]));
+    const toActivate = [];
+    const toDeactivate = [];
+    for (const fullName of selectedFullNames) {
+      const item = currentItemsMap.get(fullName);
+      if (item) {
+        if (item.active) {
+          toDeactivate.push(fullName);
+        } else {
+          toActivate.push(fullName);
+        }
+      }
+    }
+    let previewMessage = `Changes to apply:
+`;
+    if (toDeactivate.length > 0) {
+      previewMessage += `
+  Deactivate (${toDeactivate.length}):
+`;
+      toDeactivate.forEach((name) => {
+        previewMessage += `    - ${name}
+`;
+      });
+    }
+    if (toActivate.length > 0) {
+      previewMessage += `
+  Activate (${toActivate.length}):
+`;
+      toActivate.forEach((name) => {
+        previewMessage += `    - ${name}
+`;
+      });
+    }
+    previewMessage += "\nBackup will be created automatically.";
+    this.prompts.note(previewMessage, "Preview");
+    const confirmed = await this.prompts.confirm("Proceed with these changes?");
+    if (!confirmed) {
+      this.prompts.cancel("Operation cancelled");
+      return;
+    }
+    const operationId = this.logger.generateOperationId();
+    const backupSpinner = this.prompts.spinner();
+    backupSpinner.start("Creating backup...");
+    const backupItems = selectedFullNames.map((fn) => currentItemsMap.get(fn));
+    const backupPath = await this.backupManager.save(
+      org,
+      selectedObject,
+      automationType,
+      backupItems,
+      [],
+      "individual"
+    );
+    backupSpinner.stop("Backup created");
+    const applySpinner = this.prompts.spinner();
+    applySpinner.start("Applying changes...");
+    try {
+      await this.applyChanges(
+        handler,
+        connection,
+        selectedObject,
+        automationType,
+        toDeactivate,
+        toActivate,
+        currentItemsMap
+      );
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: selectedObject,
+        type: automationType,
+        status: "success",
+        itemsAffected: selectedFullNames.length,
+        itemsSkipped: 0,
+        backupPath,
+        error: null
+      });
+      applySpinner.stop("Changes applied");
+      this.prompts.success(
+        `Successfully modified ${selectedFullNames.length} ${automationType}.`
+      );
+    } catch (error) {
+      applySpinner.stop("Changes failed");
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: selectedObject,
+        type: automationType,
+        status: "failure",
+        itemsAffected: 0,
+        itemsSkipped: 0,
+        backupPath,
+        error: error.message
+      });
+      this.prompts.error(`Failed to apply changes: ${error.message}`);
+      throw error;
+    }
+  }
+  async applyChanges(handler, connection, objectName, automationType, toDeactivate, toActivate, itemsMap) {
+    if (automationType === "validation-rules") {
+      const vrHandler = handler;
+      if (toDeactivate.length > 0) {
+        const ruleNames = toDeactivate.map((fn) => fn.split(".")[1]);
+        await vrHandler.deactivate(connection, objectName, ruleNames);
+      }
+      if (toActivate.length > 0) {
+        const ruleNames = toActivate.map((fn) => fn.split(".")[1]);
+        await vrHandler.activate(connection, objectName, ruleNames);
+      }
+    } else if (automationType === "flows") {
+      const flowHandler = handler;
+      if (toDeactivate.length > 0) {
+        const flowIds = toDeactivate.map((fn) => {
+          const item = itemsMap.get(fn);
+          return item.metadata.Id;
+        });
+        await flowHandler.deactivate(connection, flowIds);
+      }
+      if (toActivate.length > 0) {
+        const flowsWithVersions = toActivate.map((fn) => {
+          const item = itemsMap.get(fn);
+          return {
+            id: item.metadata.Id,
+            version: item.metadata.LatestVersion.VersionNumber
+          };
+        });
+        await flowHandler.activate(connection, flowsWithVersions);
+      }
+    } else {
+      const triggerHandler = handler;
+      if (toDeactivate.length > 0) {
+        await triggerHandler.deactivate(connection, toDeactivate);
+      }
+      if (toActivate.length > 0) {
+        await triggerHandler.activate(connection, toActivate);
+      }
+    }
+  }
+};
+
+// src/commands/automations.ts
+var AutomationsCommand = class {
+  prompts;
+  constructor() {
+    this.prompts = new Prompts();
+  }
+  async execute() {
+    const action = await this.prompts.selectFromOptions(
+      "Automations",
+      [
+        { value: "deactivate", label: "Deactivate all" },
+        { value: "restore", label: "Restore" },
+        { value: "individual", label: "Manage individually" },
+        { value: "back", label: "Back to main menu" }
+      ]
+    );
+    switch (action) {
+      case "deactivate":
+        const deactivateCmd = new DeactivateCommand();
+        await deactivateCmd.execute();
+        break;
+      case "restore":
+        const restoreCmd = new RestoreCommand();
+        await restoreCmd.execute();
+        break;
+      case "individual":
+        const individualCmd = new IndividualCommand();
+        await individualCmd.execute();
+        break;
+      case "back":
+        return;
+    }
+  }
+};
+
+// src/commands/backups.ts
 import * as fs3 from "fs/promises";
 import * as path4 from "path";
-var ManageCommand = class {
+var BackupsCommand = class {
   backupManager;
   prompts;
   constructor() {
@@ -1019,7 +1305,7 @@ var ManageCommand = class {
   }
   async execute() {
     const action = await this.prompts.selectFromOptions(
-      "What would you like to do?",
+      "Backups",
       [
         { value: "view", label: "View all backups" },
         { value: "cleanup", label: "Clean up old backups" },
@@ -1116,6 +1402,31 @@ var LogsCommand = class {
   }
 };
 
+// src/commands/logs-menu.ts
+var LogsMenuCommand = class {
+  prompts;
+  constructor() {
+    this.prompts = new Prompts();
+  }
+  async execute() {
+    const action = await this.prompts.selectFromOptions(
+      "Logs",
+      [
+        { value: "view", label: "View recent operations" },
+        { value: "back", label: "Back to main menu" }
+      ]
+    );
+    switch (action) {
+      case "view":
+        const logsCmd = new LogsCommand();
+        await logsCmd.execute();
+        break;
+      case "back":
+        return;
+    }
+  }
+};
+
 // src/index.ts
 async function main() {
   const prompts = new Prompts();
@@ -1124,20 +1435,16 @@ async function main() {
     while (true) {
       const action = await prompts.selectMainAction();
       switch (action) {
-        case "deactivate":
-          const deactivateCmd = new DeactivateCommand();
-          await deactivateCmd.execute();
-          break;
-        case "restore":
-          const restoreCmd = new RestoreCommand();
-          await restoreCmd.execute();
+        case "automations":
+          const automationsCmd = new AutomationsCommand();
+          await automationsCmd.execute();
           break;
-        case "manage":
-          const manageCmd = new ManageCommand();
-          await manageCmd.execute();
+        case "backups":
+          const backupsCmd = new BackupsCommand();
+          await backupsCmd.execute();
           break;
         case "logs":
-          const logsCmd = new LogsCommand();
+          const logsCmd = new LogsMenuCommand();
           await logsCmd.execute();
           break;
         case "exit":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inforge/migrations-tools-cli",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Inforge's interactive CLI for side-effect-free Salesforce data operations by managing automation",
   "main": "index.js",
   "type": "module",