proca 1.7.8 → 1.8.3

package/src/commands/campaign/queries.graphql

@@ -1,19 +1,19 @@
 query SearchCampaigns($name: String!) {
-	campaigns(name: $name) {
-		id
-		name
-		title
-		config
-	}
+  campaigns(name: $name) {
+    id
+    name
+    title
+    config
+  }
 }
 
 query GetOrgCampaigns($org: String!) {
-	org(name: $org) {
-		campaigns {
-			id
-			name
-			title
-			config
-		}
-	}
+  org(name: $org) {
+    campaigns {
+      id
+      name
+      title
+      config
+    }
+  }
 }

package/src/commands/campaign/status.mjs

@@ -4,31 +4,31 @@ import Command from "#src/procaCommand.mjs";
 import { gql, mutation } from "#src/urql.mjs";
 
 export default class CampaignStatus extends Command {
-	static args = this.multiid();
-	static aliases = ["campaign:close"];
-
-	static examples = [
-		"<%= config.bin %> <%= command.id %> -name <campaign>",
-		"<%= config.bin %> <%= command.id %> -i <campaign_id>",
-	];
-
-	static isCloseCommand =
-		process.argv.includes("close") ||
-		this.commandPath?.includes("close") ||
-		this.id?.includes("close");
-
-	static flags = {
-		status: Flags.string({
-			...this.flagify({ multiid: true }),
-			description: "Status to set",
-			required: true,
-			default: this.isCloseCommand ? "close" : undefined,
-			options: ["draft", "live", "closed", "ignored"],
-		}),
-	};
-
-	updateStatus = async (props) => {
-		const Query = gql`
+  static args = this.multiid();
+  static aliases = ["campaign:close"];
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> -name <campaign>",
+    "<%= config.bin %> <%= command.id %> -i <campaign_id>",
+  ];
+
+  static isCloseCommand =
+    process.argv.includes("close") ||
+    this.commandPath?.includes("close") ||
+    this.id?.includes("close");
+
+  static flags = {
+    status: Flags.string({
+      ...this.flagify({ multiid: true }),
+      description: "Status to set",
+      required: true,
+      default: this.isCloseCommand ? "close" : undefined,
+      options: ["draft", "live", "closed", "ignored"],
+    }),
+  };
+
+  updateStatus = async (props) => {
+    const Query = gql`
 mutation (
 $id: Int,
 $name: String
@@ -43,21 +43,21 @@ $status: String!
 }
     `;
 
-		const result = await mutation(Query, {
-			//			org: props.org,
-			id: props.id,
-			name: props.name,
-			status: props.status.toUpperCase(),
-		});
+    const result = await mutation(Query, {
+      //			org: props.org,
+      id: props.id,
+      name: props.name,
+      status: props.status.toUpperCase(),
+    });
 
-		console.log("result", result);
-		return result.updateCampaign;
-	};
+    console.log("result", result);
+    return result.updateCampaign;
+  };
 
-	async run() {
-		const { args, flags } = await this.parse();
+  async run() {
+    const { args, flags } = await this.parse();
 
-		const data = await this.updateStatus(flags);
-		return this.output(data);
-	}
+    const data = await this.updateStatus(flags);
+    return this.output(data);
+  }
 }

package/src/commands/campaign/widget/archive.mjs

@@ -0,0 +1,124 @@
+import { Flags } from "@oclif/core";
+import prompts from "prompts";
+import CampaignGet from "#src/commands/campaign/get.mjs";
+import WidgetList from "#src/commands/widget/list.mjs";
+import WidgetUpdate from "#src/commands/widget/update.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignWidgetArchive extends Command {
+  static args = this.multiid(); // Add this!
+
+  static description = "Archive all widgets in the campaign by adding suffix";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> old_campaign",
+    "<%= config.bin %> <%= command.id %> -n old_campaign --suffix _backup",
+    "<%= config.bin %> <%= command.id %> old_campaign --dry-run",
+  ];
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    suffix: Flags.string({
+      char: "s",
+      description: "custom suffix to append (default: _archive)",
+      helpValue: "<suffix>",
+      default: "_archive",
+    }),
+    "dry-run": Flags.boolean({
+      description: "preview changes without executing",
+      default: false,
+    }),
+  };
+
+  fetchCampaign = async ({ id, name }) => {
+    const campaignGet = new CampaignGet([], this.config);
+    return await campaignGet.fetch({ id, name });
+  };
+
+  fetchWidgets = async (campaignName) => {
+    const widgetList = new WidgetList([], this.config);
+    widgetList.flags = { campaign: campaignName, config: true };
+    return await widgetList.fetchCampaign(campaignName);
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const { id, name, suffix, "dry-run": dryRun } = flags;
+
+    this.log(`Fetching source campaign: ${name || id}`);
+    const campaign = await this.fetchCampaign({ id, name });
+
+    if (!campaign) {
+      this.error("Campaign not found");
+      return;
+    }
+
+    this.log(`Fetching widgets for campaign: ${campaign.name}`);
+    const widgets = await this.fetchWidgets(campaign.name);
+
+    if (!widgets || widgets.length === 0) {
+      this.warn("No widgets found for this campaign");
+      return;
+    }
+
+    this.log(`Found ${widgets.length} widgets`);
+
+    const renameList = widgets.map((widget) => ({
+      id: widget.id,
+      oldName: widget.name,
+      newName: `${widget.name}${suffix}`,
+      locale: widget.locale,
+    }));
+
+    this.log("\nArchive plan:");
+    this.table(renameList);
+
+    if (dryRun) {
+      this.log("\n[DRY RUN] No changes made");
+      return renameList;
+    }
+
+    // Confirm before proceeding
+    const response = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: `Archive ${renameList.length} widgets by adding suffix "${suffix}"?`,
+      initial: false,
+    });
+
+    if (!response.proceed) {
+      this.log("Cancelled");
+      return;
+    }
+
+    const widgetUpdate = new WidgetUpdate([], this.config);
+    const results = [];
+
+    for (const item of renameList) {
+      try {
+        this.log(`Archiving: ${item.oldName} → ${item.newName}`);
+        const input = {
+          name: item.newName,
+          locale: item.locale,
+        };
+        const result = await widgetUpdate.update(item.id, input);
+        results.push({
+          id: result.id,
+          name: result.name,
+          status: "success",
+        });
+      } catch (error) {
+        this.error(`Failed to archive ${item.oldName}: ${error.message}`);
+        results.push({
+          id: item.id,
+          name: item.oldName,
+          status: "failed",
+          error: error.message,
+        });
+      }
+    }
+
+    this.log("\nArchive complete!");
+    return this.output(results);
+  }
+}

package/src/commands/campaign/widget/copy.mjs

@@ -0,0 +1,175 @@
+import { Flags } from "@oclif/core";
+import prompts from "prompts";
+import CampaignGet from "#src/commands/campaign/get.mjs";
+import WidgetAdd from "#src/commands/widget/add.mjs";
+import WidgetList from "#src/commands/widget/list.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignWidgetCopy extends Command {
+  static args = this.multiid();
+
+  static description = "Copy widgets from one campaign to another";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> old_campaign --to new_campaign",
+    "<%= config.bin %> <%= command.id %> -n old_campaign --to new_campaign",
+    "<%= config.bin %> <%= command.id %> old_campaign --to new_campaign --suffix _archive",
+    "<%= config.bin %> <%= command.id %> old_campaign --to new_campaign --dry-run",
+  ];
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    to: Flags.string({
+      char: "t",
+      required: true,
+      description: "destination campaign name",
+      helpValue: "<campaign name>",
+    }),
+    suffix: Flags.string({
+      char: "s",
+      description: "suffix to remove from widget names (e.g., _archive, -v1)",
+      helpValue: "<suffix>",
+      default: "_archive",
+    }),
+    "dry-run": Flags.boolean({
+      description: "preview changes without executing",
+      default: false,
+    }),
+  };
+
+  fetchCampaign = async ({ id, name }) => {
+    const campaignGet = new CampaignGet([], this.config);
+    return await campaignGet.fetch({ id, name });
+  };
+
+  fetchWidgets = async (campaignName) => {
+    const widgetList = new WidgetList([], this.config);
+    widgetList.flags = { campaign: campaignName, config: true };
+    return await widgetList.fetchCampaign(campaignName);
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const { id, name, to, suffix, "dry-run": dryRun } = flags;
+
+    this.log(`Fetching source campaign: ${name || id}`);
+    const sourceCampaign = await this.fetchCampaign({ id, name });
+
+    if (!sourceCampaign) {
+      this.error(`Source campaign not found: ${name || id}`);
+      return;
+    }
+
+    this.log(`Fetching widgets from: ${sourceCampaign.name}`);
+    const sourceWidgets = await this.fetchWidgets(sourceCampaign.name);
+
+    if (!sourceWidgets || sourceWidgets.length === 0) {
+      this.warn("No widgets found in source campaign");
+      return;
+    }
+
+    this.log(`Found ${sourceWidgets.length} widgets`);
+
+    const widgets = sourceWidgets.map((widget) => {
+      const newName = widget.name.replace(suffix, "");
+      return {
+        newName,
+        lang: widget.locale,
+        org: widget.org.name,
+
+        config: widget.config ? JSON.stringify(widget.config) : undefined,
+
+        thankYouTemplate: widget.thankYouTemplateRef ?? widget.thankYouTemplate,
+      };
+    });
+
+    this.log("\n=== WIDGET COPY PLAN ===");
+    this.log(`From: ${sourceCampaign.name}`);
+    this.log(`To: ${to}`);
+    this.log(`\nWidgets (${widgets.length}):`);
+    this.table(widgets);
+
+    if (dryRun) {
+      this.log("\n[DRY RUN] No changes made");
+      return widgets;
+    }
+
+    const response = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: `Copy ${widgets.length} widgets to campaign "${to}"?`,
+      initial: false,
+    });
+
+    if (!response.proceed) {
+      this.log("Cancelled");
+      return;
+    }
+
+    this.log("\nCopying widgets...");
+    const widgetAdd = new WidgetAdd([], this.config);
+    const results = [];
+
+    for (const widget of widgets) {
+      try {
+        this.log(`  Creating: ${widget.newName}`);
+        const created = await widgetAdd.create({
+          campaign: to,
+          org: widget.org,
+          name: widget.newName,
+          lang: widget.lang,
+
+          config: widget.config,
+          thankYouTemplate: widget.thankYouTemplate,
+        });
+
+        results.push({
+          name: widget.newName,
+          id: created.id,
+          status: "success",
+        });
+      } catch (error) {
+        if (error.message.includes("invalid name (already taken?)")) {
+          // Just log and continue for existing widgets
+          this.log(`  ⚠ Skipped (already exists): ${widget.newName}`);
+          results.push({
+            name: widget.newName,
+            status: "skipped",
+            reason: "already exists",
+          });
+        } else if (
+          error.message.includes("User is not a member of organisation")
+        ) {
+          // Skip widgets where user doesn't have permission
+          this.log(
+            `  ⚠ Skipped (no permission): ${widget.newName} (org: ${widget.org})`,
+          );
+          results.push({
+            name: widget.newName,
+            status: "skipped",
+            reason: "no permission",
+            org: widget.org,
+          });
+        } else {
+          this.warn(`  Failed to create ${widget.newName}: ${error.message}`);
+          results.push({
+            name: widget.newName,
+            status: "failed",
+            error: error.message,
+          });
+        }
+      }
+    }
+
+    this.log("\n=== COPY COMPLETE ===");
+    const successful = results.filter((r) => r.status === "success").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+
+    this.log(`Widgets created: ${successful}`);
+    if (skipped > 0) this.log(`Widgets skipped: ${skipped}`);
+    if (failed > 0) this.warn(`Widgets failed: ${failed}`);
+
+    return this.output(results);
+  }
+}

package/src/commands/campaign/widget/get.mjs

@@ -0,0 +1,19 @@
+import Command from "#src/procaCommand.mjs";
+import WidgetList from "../../widget/list.mjs";
+
+export default class CampaignWidgetList extends Command {
+  static description = "List widgets in a campaign";
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+
+    // Delegate to widget list, but with campaign pre-filled
+    await WidgetList.run(["--campaign", flags.name], this.config);
+  }
+}

package/src/commands/campaign/widget/index.mjs

@@ -0,0 +1,17 @@
+import { Command } from "@oclif/core";
+
+export default class CampaignWidget extends Command {
+  static description = "commands for multiple widgets in a campaign";
+  static aliases = ["campaign:widget"];
+  static hidden = true; // Hide from command list, only show as topic
+
+  static id = "campaign:widget";
+
+  async run() {
+    const { Help } = await import("@oclif/core");
+    const help = new Help(this.config, { all: true });
+    const formatted = help.formatCommand(this);
+    this.log(formatted);
+    //    this.error("Please specify a subcommand, run with --help to list them");
+  }
+}

package/src/commands/campaign/widget/rebuild.mjs

@@ -0,0 +1,50 @@
+import WidgetList from "#src/commands/widget/list.mjs";
+import WidgetRebuild from "#src/commands/widget/rebuild.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignWidgetRebuild extends Command {
+  static description = "(re)build all the widgets of a campaign";
+
+  static examples = ["$ proca-cli campaign widget rebuild climate-action"];
+
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+    //    dryRun: Flags.boolean({
+    //      description: 'Show what would be rebuilt without actually doing it',
+    //    }),
+  };
+
+  simplify = (d) => {
+    d.location = undefined;
+    d.config = undefined;
+    d.org = d.org.name;
+    return d;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  rebuild = async (props) => {
+    const wapi = new WidgetList();
+    const rebuildapi = new WidgetRebuild();
+    wapi.flags.config = true; //we need to fetch each widget config
+    const widgets = await wapi.fetchCampaign(props.name); //list all widgets
+    const result = [];
+    for (const widget of widgets) {
+      // do not process all widgets in parallel but in sequence
+      const r = await rebuildapi.rebuild({ widget });
+      result.push(r);
+    }
+    return result;
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const r = await this.rebuild(flags);
+    return this.output(r);
+  }
+}