@proca/cli 3.4.5 → 3.8.3

package/src/commands/action/list.mjs

@@ -0,0 +1,204 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import {
+  FragmentOrg,
+  FragmentStats,
+  FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class List extends Command {
+  actionTypes = new Set();
+
+  static args = {
+    title: Args.string({ description: "name of the campaign, % for wildchar" }),
+  };
+
+  static examples = ["<%= config.bin %> <%= command.id %> %pizza%"];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "campaigns of the organisation (coordinator or partner)",
+      required: true,
+      //			exactlyOne: ["org", "title"],
+      helpValue: "<organisation name>",
+    }),
+    campaign: Flags.string({
+      char: "c",
+      description: "name of the campaign, % for wildchar",
+      helpValue: "<campaign name>",
+    }),
+    limit: Flags.string({
+      description: "max number of actions",
+      parse: (input) => Number.parseInt(input, 10),
+    }),
+    after: Flags.string({
+      description: "only actions after a date",
+      helpValue: "2025-04-09",
+      parse: (input) => new Date(input).toISOString(),
+    }),
+    today: Flags.boolean({
+      description: "only actions today",
+      exclusive: ["after"],
+      parse: (input) => `${new Date().toISOString().split("T")[0]}T00:00:00Z`,
+    }),
+    optin: Flags.boolean({
+      description: "only export the optin actions",
+      default: false,
+    }),
+    testing: Flags.boolean({
+      description: "also export the test actions",
+      default: false,
+    }),
+    doi: Flags.boolean({
+      description: "only export the double optin actions",
+      default: false,
+    }),
+    utm: Flags.boolean({
+      description: "display the utm tracking parameters",
+      default: true,
+      allowNo: true,
+      exclusive: ["simplify"],
+    }),
+    comment: Flags.boolean({
+      description: "display the comment",
+      default: true,
+      allowNo: true,
+      exclusive: ["simplify"],
+    }),
+  };
+
+  fetch = async (flags) => {
+    const Document = gql`
+      query (
+        $after: DateTime
+        $campaignId: Int
+        $campaignName: String
+        $includeTesting: Boolean
+        $limit: Int
+        $onlyDoubleOptIn: Boolean
+        $onlyOptIn: Boolean
+        $orgName: String!
+        $start: Int
+      ) {
+        actions (
+          after: $after
+          campaignId: $campaignId
+          campaignName: $campaignName
+          includeTesting: $includeTesting
+          limit: $limit
+          onlyDoubleOptIn: $onlyDoubleOptIn
+          onlyOptIn: $onlyOptIn
+          orgName: $orgName
+          start: $start
+        ) {
+          actionId
+          actionPage {
+            locale
+            name
+          }
+          actionType
+          campaign {
+            name
+          }
+          contact {
+            contactRef
+            payload
+            nonce
+            publicKey {
+              public
+            }
+          }
+          createdAt
+          customFields
+          privacy {
+            emailStatus
+            emailStatusChanged
+            givenAt
+            optIn
+            withConsent
+          }
+          tracking {
+            campaign
+            content
+            medium
+            source
+          }
+        }
+      }
+    `;
+    const result = await query(Document, {
+      after: flags.after,
+      //  "campaignId": 42,
+      campaignName: flags.campaign,
+      includeTesting: flags.testing,
+      limit: flags.limit,
+      onlyDoubleOptIn: flags.doi,
+      onlyOptIn: flags.optin,
+      orgName: flags.org,
+      start: flags.start,
+    });
+    return result.actions.map((d) => {
+      d.customFields = JSON.parse(d.customFields);
+      if (!d.contact.publicKey) {
+        const ref = d.contactRef;
+        d.contact = JSON.parse(d.contact.payload);
+        d.contact.contactRef = ref;
+      } else {
+        this.error(
+          `encrypted contact we need the private key for ${d.contact.publicKey.public}`,
+        );
+      }
+      return d;
+    });
+    //		return result.exportActions;
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.actionId,
+      firstname: d.contact.firstName,
+      country: d.contact.country,
+      email: d.contact.email,
+      type: d.actionType,
+      date: d.createdAt,
+      campaign: d.campaign.name,
+      widget_id: d.actionPage.id,
+      widget: d.actionPage.name,
+      //            customFields
+    };
+    if (this.flags.comment && d.customFields?.comment)
+      result.comment = d.customFields.comment;
+    if (d.customFields?.emailProvider)
+      result.provider = d.customFields.emailProvider;
+    if (this.flags.utm && d.tracking) {
+      result.utm_medium =
+        d.tracking.medium === "unknown" ? undefined : d.tracking.medium;
+      result.utm_source =
+        d.tracking.source === "unknown" ? undefined : d.tracking.source;
+      result.utm_campaign =
+        d.tracking.campaign === "unknown" ? undefined : d.tracking.campaign;
+      if (d.tracking.content)
+        result.utm_content =
+          d.tracking.content === "unknown" ? undefined : d.tracking.content;
+    }
+    return result;
+  };
+
+  _table = (r) => {
+    super.table(r, null, (table) => table.sort(["id|des"]).toString());
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    if (flags.today) flags.after = flags.today;
+    let data = [];
+
+    data = await this.fetch(flags);
+    return this.output(data);
+  }
+}

package/src/commands/action/replay.mjs

@@ -0,0 +1,56 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class ReplayAction extends Command {
+  static examples = ["<%= config.bin %> <%= command.id %> %pizza%"];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "campaigns of the organisation (coordinator or partner)",
+      required: true,
+      //			exactlyOne: ["org", "title"],
+      helpValue: "<organisation name>",
+    }),
+    /*    queue: Flag.string({
+      default: "CUSTOM_ACTION_DELIVER",
+options: [
+    'CUSTOM_ACTION_CONFIRM',
+    'CUSTOM_ACTION_DELIVER',
+    'CUSTOM_SUPPORTER_CONFIRM',
+    'EMAIL_SUPPORTER',
+    'SQS',
+    'WEBHOOK'
+],
+    }),
+*/
+    campaign: Flags.string({
+      char: "c",
+      description: "name of the campaign, % for wildchar",
+      helpValue: "<campaign title>",
+    }),
+  };
+
+  mutate = async (org, id, queue) => {
+    const Document = gql`
+        mutation Requeue($org: String!, $ids: [Int!]!, $queue: Queue!){
+            requeueActions(orgName:$org, ids: $ids, queue: $queue) {
+                count failed
+            }
+        }`;
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    let data = [];
+    const ids = [];
+    this.fatal("not implemented yet");
+    process.exit(1);
+    data = await this.mutate(flags.org, ids, flags.queue);
+    return this.output(data);
+  }
+}

package/src/commands/action/requeue.mjs

@@ -0,0 +1,156 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation, query } from "#src/urql.mjs";
+
+export default class ActionRequeue extends Command {
+  static description = "requeue actions";
+
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+
+  static flags = {
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      required: true,
+      description: "name of the org",
+      helpValue: "<org name>",
+    }),
+    campaign: Flags.string({
+      char: "c",
+      description: "name of the campaign, % for wildchar",
+      helpValue: "<campaign name>",
+    }),
+    queue: Flags.string({
+      char: "q",
+      required: true,
+      description: "queue to redeliver to",
+      default: "CUSTOM_ACTION_DELIVER",
+      options: [
+        "CUSTOM_ACTION_CONFIRM",
+        "CUSTOM_ACTION_DELIVER",
+        "CUSTOM_SUPPORTER_CONFIRM",
+        "EMAIL_SUPPORTER",
+        "SQS",
+        "WEBHOOK",
+      ],
+    }),
+    limit: Flags.string({
+      description: "how many actions per page",
+      default: 1000,
+      parse: (input) => Number.parseInt(input, 10),
+    }),
+    after: Flags.string({
+      description: "only actions after a date",
+      helpValue: "2025-04-09",
+      parse: (input) => new Date(input).toISOString(),
+    }),
+    today: Flags.boolean({
+      description: "only actions today",
+      exclusive: ["after"],
+      parse: (input) => `${new Date().toISOString().split("T")[0]}T00:00:00Z`,
+    }),
+    optin: Flags.boolean({
+      description: "only export the optin actions",
+      default: false,
+    }),
+    testing: Flags.boolean({
+      description: "also export the test actions",
+      default: false,
+    }),
+    doi: Flags.boolean({
+      description: "only export the double optin actions",
+      default: false,
+    }),
+  };
+
+  process = async (flags) => {
+    let page = 0;
+    let actions = 0;
+    let requeued = 0;
+    let error = 0;
+    while (true) {
+      const ids = await this.fetch(flags);
+      if (ids.length === 0) break;
+      const result = await this.requeue(flags.org, flags.queue, ids);
+      requeued += result.count;
+      error += result.failed;
+      flags.start = ids[ids.length - 1] + 1;
+      process.stdout.write(`\rrequeued ${requeued}, id> ${flags.start}`);
+      page += 1;
+      actions += ids.length;
+    }
+    process.stdout.write("\r\x1b[K");
+    return { pages: page, actions, requeued, error };
+  };
+
+  fetch = async (flags) => {
+    const Document = gql`
+      query (
+        $after: DateTime
+        $campaignId: Int
+        $campaignName: String
+        $includeTesting: Boolean
+        $limit: Int
+        $onlyDoubleOptIn: Boolean
+        $onlyOptIn: Boolean
+        $orgName: String!
+        $start: Int
+      ) {
+        actions (
+          after: $after
+          campaignId: $campaignId
+          campaignName: $campaignName
+          includeTesting: $includeTesting
+          limit: $limit
+          onlyDoubleOptIn: $onlyDoubleOptIn
+          onlyOptIn: $onlyOptIn
+          orgName: $orgName
+          start: $start
+        ) {
+          actionId
+          }
+      }
+    `;
+    const result = await query(Document, {
+      after: flags.after,
+      campaignName: flags.campaign,
+      includeTesting: flags.testing,
+      limit: flags.limit,
+      onlyDoubleOptIn: flags.doi,
+      onlyOptIn: flags.optin,
+      orgName: flags.org,
+      start: flags.start,
+    });
+    const ids = [];
+    result.actions.forEach((d) => ids.push(d.actionId));
+    return ids;
+  };
+
+  requeue = async (org, queue, ids) => {
+    const Document = gql`
+mutation ($ids: [Int!], $org: String!, $queue: Queue!) {
+  requeueActions(ids: $ids, orgName: $org, queue: $queue) {
+    count
+    failed
+  }
+}`;
+    const result = await mutation(Document, {
+      org,
+      queue,
+      ids,
+    });
+    //return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+    return result.requeueActions;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    const data = await this.process(flags);
+    this.output(data);
+  }
+}

package/src/commands/campaign/add.mjs

@@ -0,0 +1,113 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import OrgGet from "#src/commands/org/get.mjs";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+import { getTwitter } from "#src/util/twitter.mjs";
+
+export default class CampaignAdd extends Command {
+  static args = {
+    title: Args.string({
+      description: "title of the campaign",
+      multiple: true,
+    }),
+  };
+  //  static strict = false;
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> -n <new_campaign> the full name of the campaign",
+  ];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    name: Flags.string({
+      char: "n",
+      description: "name of the campaign",
+      helpValue: "<campaign name>",
+      required: true,
+    }),
+    org: Flags.string({
+      char: "o",
+      description: "name of the coordinator",
+      helpValue: "<org name>",
+      required: true,
+    }),
+  };
+
+  create = async (campaign, customConfig = null) => {
+    const org = await this.getOrg(campaign.org);
+
+    let config;
+
+    // Use custom config if provided, otherwise create default
+    if (customConfig) {
+      config =
+        typeof customConfig === "string"
+          ? JSON.parse(customConfig)
+          : customConfig;
+    } else {
+      // Default config creation (existing functionality)
+      config = {
+        locales: {
+          en: {
+            "campaign:": {
+              description: "",
+            },
+            "common:": {},
+          },
+        },
+      };
+
+      if (org.config.locale && org.config.locale !== "en") {
+        config.locales[org.config.locale] = {};
+      }
+
+      if (!config.portal) {
+        config.portal = [];
+      }
+    }
+
+    const AddOrgDocument = gql`
+        mutation ($org: String!
+        $name: String!
+        $title: String!
+        $config: Json!
+        ) {
+          addCampaign (input: { name: $name, title: $title, config: $config }, orgName: $org) {
+            name
+            title
+            config
+          }
+        }
+    `;
+
+    const result = await mutation(AddOrgDocument, {
+      org: org.name,
+      name: campaign.name,
+      title: campaign.title,
+      config: JSON.stringify(config),
+    });
+
+    console.log("result", result);
+    return result;
+  };
+
+  async getOrg(orgName) {
+    const { config } = this;
+    const orgGet = new OrgGet({}, this.config);
+    const org = await orgGet.fetch({ name: orgName });
+    return org;
+  }
+
+  async run() {
+    const { args, flags } = await this.parse();
+    const campaign = {
+      org: flags.org,
+      name: flags.name,
+      title: args.title || flags.name,
+    };
+    const data = await this.create(campaign);
+    return this.output(data);
+  }
+}

package/src/commands/campaign/copy.mjs

@@ -0,0 +1,91 @@
+import { Flags } from "@oclif/core";
+import CampaignAdd from "#src/commands/campaign/add.mjs";
+import CampaignGet from "#src/commands/campaign/get.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignCopy extends Command {
+  static args = this.multiid();
+
+  static description = "Copy campaign settings to a new campaign";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> test_2025 --to test_2026",
+    "<%= config.bin %> <%= command.id %> -n old_campaign --to new_campaign -o different_org",
+  ];
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    to: Flags.string({
+      char: "t",
+      required: true,
+      description: "new campaign name",
+      helpValue: "<campaign name>",
+    }),
+    org: Flags.string({
+      char: "o",
+      description:
+        "organization for the new campaign (defaults to source campaign org)",
+      helpValue: "<org name>",
+    }),
+    title: Flags.string({
+      description:
+        "title for the new campaign (defaults to source campaign title)",
+      helpValue: "<campaign title>",
+    }),
+    "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 });
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const { id, name, to, org, title, "dry-run": dryRun } = flags;
+
+    this.log(`Fetching source campaign: ${name || id}`);
+    const sourceCampaign = await this.fetchCampaign({ id, name });
+
+    const newCampaign = {
+      name: to,
+      title: title || sourceCampaign.title,
+      org: org || sourceCampaign.org.name,
+    };
+
+    this.log("\n=== CAMPAIGN COPY ===");
+    this.log(`Source: ${sourceCampaign.name}`);
+    this.log("\nNew Campaign:");
+    this.log(`  Name: ${newCampaign.name}`);
+    this.log(`  Title: ${newCampaign.title}`);
+    this.log(`  Org: ${newCampaign.org}`);
+
+    if (dryRun) {
+      this.log("\n[DRY RUN] No changes made");
+      return newCampaign;
+    }
+
+    this.log(`\nCreating campaign: ${to}`);
+    try {
+      const campaignAdd = new CampaignAdd([], this.config);
+
+      const result = await campaignAdd.create(
+        {
+          org: newCampaign.org,
+          name: newCampaign.name,
+          title: newCampaign.title,
+        },
+        sourceCampaign.config,
+      );
+
+      this.log(`✓ Campaign created: ${result.addCampaign.name}`);
+      return this.output(result.addCampaign);
+    } catch (error) {
+      this.error(`Failed to create campaign: ${error.message}`);
+      return;
+    }
+  }
+}

package/src/commands/campaign/delete.mjs

@@ -0,0 +1,41 @@
+import { Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class CampaignDelete extends Command {
+  static args = this.multiid();
+
+  static description = "delete a campaign";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> 42",
+    "<%= config.bin %> <%= command.id %> -i 42",
+    "<%= config.bin %> <%= command.id %> my_campaign",
+    "<%= config.bin %> <%= command.id %> -n my_campaign",
+  ];
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+  };
+
+  mutate = async ({ id, name }) => {
+    const Document = gql`
+      mutation ($id: Int, $name: String) {
+        deleteCampaign(id: $id, name: $name)
+      }
+    `;
+    const result = await mutation(Document, { id, name });
+    return result.deleteCampaign;
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const { id, name } = flags;
+
+    if (!id && !name) {
+      this.error("You must specify a campaign id or name");
+    }
+
+    const data = await this.mutate({ id, name });
+    return this.output(data);
+  }
+}