@proca/cli 3.4.5 → 3.8.3

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);
+  }
+}

package/src/commands/config/add.mjs

@@ -0,0 +1,97 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout } from "@oclif/core/ux";
+import prompts from "prompts";
+import { format, get as getConfig, getFilename, write } from "#src/config.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class ConfigAdd extends Command {
+  static enableJsonFlag = true;
+  static aliases = ["config:setup", "config:init"];
+  //	static deprecateAliases = true;
+
+  static args = {
+    ...this.flagify({ multiid: false }),
+  };
+
+  static description = "create setting to access to a server";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --user=xavier@example.org --token=API-12345789",
+  ];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    url: Flags.string({
+      description: "url of the proca server api",
+      default: "https://api.proca.app/api",
+      helpValue: "http://localhost:4000",
+    }),
+    token: Flags.string({
+      description: "user token on proca server",
+      helpValue: "API-token>",
+    }),
+    email: Flags.string({
+      description: "user email on proca server",
+      helpValue: "you@example.org",
+    }),
+    folder: Flags.string({
+      description: "config folder (in the proca widget generator)",
+      helpValue: "/var/www/proca/config.example",
+    }),
+    //		n8n: Flags.string({			description: "api access on the n8n server",			helpValue: "<n8n api>",		}),
+    //		supabase: Flags.string({description: "url of the supabase",helpValue: "<url>"}),
+    //		"supabase-anon-key": Flags.string({			description: "anonymous key",		}),
+    //		"supabase-secrey-key": Flags.string({			description: "secret service key",		}),
+  };
+
+  generate = (flags) => {
+    const mapping = {
+      REACT_APP_NAME: "proca",
+      REACT_APP_API_URL: flags.url,
+      PROCA_TOKEN: flags.token,
+      PROCA_CONFIG_FOLDER: flags.folder,
+      N8N_TOKEN: flags.n8n,
+      REACT_APP_SUPABASE_URL: flags.supabase,
+      REACT_APP_SUPABASE_ANON_KEY: flags.supabase_anon_key,
+      SUPABASE_SECRET_KEY: flags.supabase_secret_key,
+    };
+
+    return format(mapping);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(this.constructor);
+
+    const file = getFilename(this.config.configDir, flags.env);
+    const userConfig = getConfig(file, true) || {};
+
+    if (Object.keys(userConfig).length > 0) {
+      this.log(`Config file ${file} exists. Using it to pre-fill values.`);
+    }
+
+    if (!flags.token) {
+      const response = await prompts({
+        type: "text",
+        name: "token",
+        message: this.constructor.flags.token.description,
+        initial: userConfig.PROCA_TOKEN || "API-",
+      });
+      flags.token = response.token;
+    }
+    if (!flags.folder) {
+      const response = await prompts({
+        type: "text",
+        name: "folder",
+        message: this.constructor.flags.folder.description,
+        initial: userConfig.PROCA_FOLDER,
+      });
+      flags.folder = response.folder;
+    }
+
+    if (!flags.token || !flags.token.startsWith("API-")) {
+      return error("Token must start with API-, config file not saved");
+    }
+    write(file, this.generate(flags));
+  }
+}

package/src/commands/config/folder.mjs

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Command } from "#src/procaCommand.mjs";
+
+export default class FolderConfig extends Command {
+  static summary = "Check and create config folders";
+  static description =
+    "Check if the PROCA_CONFIG_FOLDER is set up, if it is, check if the required subfolders exists and create if not";
+
+  async run() {
+    const configFolder = process.env.PROCA_CONFIG_FOLDER;
+
+    if (!configFolder) {
+      this.error("PROCA_CONFIG_FOLDER environment variable is not set.");
+    }
+
+    const subfolders = [
+      "org",
+      "target/source",
+      "target/server",
+      "target/public",
+      "campaign",
+      "email/actionpage",
+      "email/html",
+      "email/mjml",
+    ];
+
+    this.log(`Checking config folder at ${configFolder}`);
+
+    subfolders.forEach((subfolder) => {
+      const fullPath = path.join(configFolder, subfolder);
+      if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+        this.log(`🆕 ${fullPath}`);
+      } else {
+        this.log(`✅ ${fullPath}`);
+      }
+    });
+
+    this.log("Config folder check complete.");
+  }
+}

package/src/commands/config/server.mjs

@@ -0,0 +1,33 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { FragmentSummary } from "#src/queries/widget.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class ConfigServer extends Command {
+  static description = "get the server config";
+
+  fetch = async () => {
+    const Document = gql`
+query {
+  application {
+    logLevel
+    name
+    version
+  }
+}`;
+    const result = await query(Document, {});
+    return result.application;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    //		const { args, flags } = await this.parse();
+    const data = await this.fetch();
+    data.url = this.procaConfig.url;
+    return this.output(data);
+  }
+}

package/src/commands/config/set.mjs

@@ -0,0 +1,103 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import { get as getConfig, getFilename, load, write } from "#src/config.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignList extends Command {
+  static enableJsonFlag = true;
+  static aliases = ["config:setup"];
+  static deprecateAliases = true;
+
+  static args = {
+    key: Args.string({
+      description: "variable name",
+      multiple: false,
+    }),
+    value: Args.string({
+      description: "value",
+      multiple: true,
+    }),
+  };
+
+  static description =
+    "update the setting used to authenticate to the servers and services";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --user=xavier@example.org --token=API-12345789",
+    "<%= config.bin %> <%= command.id %> VAR1 VALUE",
+  ];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    environment: Flags.string({
+      description: "environment",
+      default: "default",
+    }),
+    url: Flags.string({
+      description: "url of the proca server api",
+      default: "https://api.proca.app/api",
+      helpValue: "<url>",
+    }),
+    token: Flags.string({
+      description: "user token on proca server",
+      helpValue: "<API-token>",
+    }),
+  };
+
+  format = (obj) => {
+    const content = ["# generated by proca-api"];
+    for (const [key, value] of Object.entries(obj)) {
+      if (value) {
+        content.push(`${key}='${value.replace(/'/g, "''")}'`);
+      } else {
+        content.push(`#${key}= `);
+      }
+    }
+    return content.join("\n");
+  };
+
+  generate = function () {
+    const mapping = {
+      ...args,
+      REACT_APP_NAME: "proca",
+      REACT_APP_API_URL: this.flags.url,
+      PROCA_TOKEN: this.flags.token,
+    };
+
+    return this.format(mapping);
+  };
+
+  regenerate = function (config, args) {
+    config[args.key] = args.value;
+    console.log(this.format(config));
+    process.exit(1);
+    return this.format(config);
+  };
+  async run() {
+    const config = this.config;
+    const { args, flags, raw } = await this.parse();
+    const rawf = raw.filter((d) => d.type === "flag").map((d) => d.flag);
+
+    const file = getFilename(this.config.configDir);
+
+    const userConfig = getConfig(file, true);
+
+    this.info("config file", file);
+
+    if (userConfig) {
+      if (args.key && args.value) {
+        write(file, this.regenerate(userConfig, args));
+      } else {
+        console.log(userConfig);
+        this.error("config file exists already", {
+          code: "CONFIG_ERR",
+          _ref: "README.md#",
+          suggestions: ["add KEY VALUE to update or add new variables"],
+        });
+      }
+    } else {
+      write(file, this.generate());
+    }
+  }
+}

package/src/commands/config/user.mjs

@@ -0,0 +1,79 @@
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export const getCurrentUser = () => {
+  const me = new WhoAmI([]);
+  return me.fetch();
+};
+
+export default class WhoAmI extends Command {
+  static aliases = ["user:whoami", "user:me"];
+  static description =
+    "fetch the information about the current user (based on the token)";
+
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+
+  static flags = {
+    ...super.globalFlags,
+  };
+
+  fetch = async () => {
+    const Document = gql`
+query  {
+  currentUser {
+    apiToken {
+      expiresAt
+    }
+    email
+    id
+    isAdmin
+    jobTitle
+    phone
+    pictureUrl
+    roles {
+      role org {name}
+    }
+  }
+}
+    `;
+    const result = await query(Document);
+    return result.currentUser;
+    //return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.id,
+      email: d.email,
+    };
+    if (d.apiToken) {
+      result.tokenExpire = d.apiToken.expiresAt;
+    }
+    if (d.isAdmin) {
+      result.admin = true;
+    }
+    const roles = d.roles.reduce((acc, item) => {
+      if (!acc[item.role]) {
+        acc[item.role] = [];
+      }
+      acc[item.role].push(item.org.name);
+      return acc;
+    }, {});
+    for (const role in roles) {
+      result[role] = roles[role].join(",");
+    }
+    return result;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    let data = [];
+
+    data = await this.fetch();
+
+    return this.output(data);
+  }
+}

package/src/commands/contact/count.mjs

@@ -0,0 +1,41 @@
+import { Args, Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class CounterGet extends Command {
+  static description = "counter of supporters";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --name <name of the campaign>",
+  ];
+
+  static args = this.multiid();
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+  };
+
+  fetch = async (params) => {
+    const GetCounterDocument = gql`
+      query GetCounter($name: String, $id: Int) {
+        campaign(name: $name, id: $id) {
+          stats {
+            supporterCount
+          }
+        }
+      }
+    `;
+    const result = await query(GetCounterDocument, params);
+    return result.campaign.stats;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    const data = await this.fetch(flags);
+    return this.output(data);
+  }
+}